FWItemRandomAccessor.h

Go to the documentation of this file.

#ifndef Fireworks_Core_FWItemRandomAccessor_h
#define Fireworks_Core_FWItemRandomAccessor_h
// -*- C++ -*-
//
// Package:     Core
// Class  :     FWItemRandomAccessor
//
// Original Author:  Giulio Eulisse
//         Created:  Thu Feb 18 15:19:44 EDT 2008
//

// system include files
#include "FWCore/Reflection/interface/ObjectWithDict.h"

// user include files
#include "Fireworks/Core/interface/FWItemAccessorBase.h"
#include "Fireworks/Core/interface/FWItemAccessorRegistry.h"

// forward declarations

class FWItemRandomAccessorBase : public FWItemAccessorBase {
public:
  ~FWItemRandomAccessorBase() override;

  const void *data() const override;
  const TClass *type() const override;
  const TClass *modelType() const override;

  bool isCollection() const override;

  void setData(const edm::ObjectWithDict &) override;
  void reset() override;

protected:
  void *getDataPtr() const;
  FWItemRandomAccessorBase(const TClass *type, const std::type_info &modelTypeName);
  const TClass *m_type;
  const TClass *m_modelType;
  mutable void *m_data;

public:
  FWItemRandomAccessorBase(const FWItemRandomAccessorBase &) = delete;  // stop default

  const FWItemRandomAccessorBase &operator=(const FWItemRandomAccessorBase &) = delete;  // stop default
};

template <class C, class V = typename C::value_type>
class FWItemRandomAccessor : public FWItemRandomAccessorBase {
  typedef C container_type;
  typedef V container_value_type;

public:
  FWItemRandomAccessor(const TClass *iClass) : FWItemRandomAccessorBase(iClass, typeid(container_value_type)) {}

  REGISTER_FWITEMACCESSOR_METHODS();

  // ---------- const member functions ---------------------
  const void *modelData(int iIndex) const override {
    if (!getDataPtr())
      return nullptr;
    return &(reinterpret_cast<container_type *>(getDataPtr())->operator[](iIndex));
  }

  unsigned int size() const override {
    if (!getDataPtr())
      return 0;
    return reinterpret_cast<const container_type *>(getDataPtr())->size();
  }
};

template <class C, class COLL = typename C::value_type, class V = typename COLL::value_type>
class FWItemDetSetAccessor : public FWItemRandomAccessorBase {
public:
  typedef C container_type;
  typedef COLL collection_type;
  typedef V collection_value_type;

  FWItemDetSetAccessor(const TClass *iClass) : FWItemRandomAccessorBase(iClass, typeid(collection_value_type)) {}

  REGISTER_FWITEMACCESSOR_METHODS();

  const void *modelData(int iIndex) const override {
    if (!getDataPtr())
      return nullptr;
    const container_type *c = reinterpret_cast<const container_type *>(getDataPtr());
    size_t collectionOffset = 0;
    for (typename container_type::const_iterator ci = c->begin(), ce = c->end(); ci != ce; ++ci) {
      size_t i = iIndex - collectionOffset;
      if (i < ci->size())
        return &(ci->operator[](i));
      collectionOffset += ci->size();
    }

    return nullptr;
  }

  unsigned int size() const override {
    if (!getDataPtr())
      return 0;
    const container_type *c = reinterpret_cast<const container_type *>(getDataPtr());
    size_t finalSize = 0;

    for (typename container_type::const_iterator i = c->begin(), e = c->end(); i != e; ++i)
      finalSize += i->size();

    return finalSize;
  }
};

template <class C, class COLL = typename C::value_type, class V = typename COLL::value_type>
class FWItemNewDetSetAccessor : public FWItemRandomAccessorBase {
public:
  typedef C container_type;
  typedef COLL collection_type;
  typedef V collection_value_type;

  FWItemNewDetSetAccessor(const TClass *iClass) : FWItemRandomAccessorBase(iClass, typeid(collection_value_type)) {}

  REGISTER_FWITEMACCESSOR_METHODS();

  const void *modelData(int iIndex) const override {
    if (!getDataPtr())
      return nullptr;
    const container_type *c = reinterpret_cast<const container_type *>(getDataPtr());
    if (iIndex < 0)
      return nullptr;

    return &(c->data().operator[](iIndex));
  }

  unsigned int size() const override {
    if (!getDataPtr())
      return 0;
    const container_type *c = reinterpret_cast<const container_type *>(getDataPtr());
    return c->dataSize();
  }
};

template <class C, class R = typename C::Range, class V = typename R::value_type>
class FWItemRangeAccessor : public FWItemRandomAccessorBase {
public:
  typedef C container_type;
  typedef R range_type;
  typedef V value_type;

  FWItemRangeAccessor(const TClass *iClass) : FWItemRandomAccessorBase(iClass, typeid(value_type)) {}

  REGISTER_FWITEMACCESSOR_METHODS();

  const void *modelData(int iIndex) const override {
    if (!getDataPtr())
      return nullptr;
    const container_type *c = reinterpret_cast<const container_type *>(getDataPtr());
    size_t collectionOffset = 0;
    for (typename container_type::const_iterator ci = c->begin(), ce = c->end(); ci != ce; ++ci) {
      size_t i = iIndex - collectionOffset;
      if (i < std::distance(ci->first, ci->second))
        return &(*(ci + i));
      collectionOffset += ci->size();
    }

    return nullptr;
  }

  unsigned int size() const override {
    if (!getDataPtr())
      return 0;
    const container_type *c = reinterpret_cast<const container_type *>(getDataPtr());
    size_t finalSize = 0;

    for (typename range_type::const_iterator ci = c->begin(), ce = c->end(); ci != ce; ++ci)
      finalSize += std::distance(ci->first, ci->second);

    return finalSize;
  }
};

template <class C, class V>
class FWItemMuonDigiAccessor : public FWItemRandomAccessorBase {
public:
  typedef C container_type;
  typedef V value_type;

  FWItemMuonDigiAccessor(const TClass *iClass) : FWItemRandomAccessorBase(iClass, typeid(value_type)) {}

  REGISTER_FWITEMACCESSOR_METHODS();

  const void *modelData(int iIndex) const override {
    if (!getDataPtr())
      return nullptr;
    const container_type *c = reinterpret_cast<const container_type *>(getDataPtr());
    size_t collectionOffset = 0;

    for (typename container_type::DigiRangeIterator ci = c->begin(), ce = c->end(); ci != ce; ++ci) {
      int i = iIndex - collectionOffset;

      typename container_type::DigiRangeIterator::value_type vt = *ci;

      if (i < std::distance(vt.second.first, vt.second.second))
        return &(*(vt.second.first + i));
      collectionOffset += std::distance(vt.second.first, vt.second.second);
    }

    return nullptr;
  }

  unsigned int size() const override {
    if (!getDataPtr())
      return 0;
    const container_type *c = reinterpret_cast<const container_type *>(getDataPtr());
    size_t finalSize = 0;

    for (typename container_type::DigiRangeIterator ci = c->begin(), ce = c->end(); ci != ce; ++ci) {
      typename container_type::DigiRangeIterator::value_type vt = *ci;
      finalSize += std::distance(vt.second.first, vt.second.second);
    }

    return finalSize;
  }
};

template <class C>
class BXVectorAccessor : public FWItemRandomAccessorBase {
public:
  typedef C container_type;

  BXVectorAccessor(const TClass *iClass) : FWItemRandomAccessorBase(iClass, typeid(typename C::value_type)) {}

  REGISTER_FWITEMACCESSOR_METHODS();

  const void *modelData(int iIndex) const override {
    if (!getDataPtr())
      return nullptr;

    const container_type *c = reinterpret_cast<const container_type *>(getDataPtr());

    return &(c->at(0, iIndex));
  }

  unsigned int size() const override {
    if (!getDataPtr())
      return 0;

    const container_type *c = reinterpret_cast<const container_type *>(getDataPtr());

    return c->size(0);
  }
};

#endif