RelationsObject.h

/**************************************************************************
 * BASF2 (Belle Analysis Framework 2)                                     *
 * Copyright(C) 2012-2014 - Belle II Collaboration                        *
 *                                                                        *
 * Author: The Belle II Collaboration                                     *
 * Contributors: Thomas Kuhr, Christian Pulvermacher                      *
 *                                                                        *
 * This software is provided "as is" without any warranty.                *
 **************************************************************************/
 
#pragma once
 
#include <framework/datastore/DataStore.h>
#include <framework/datastore/RelationVector.h>
#include <framework/datastore/RelationEntry.h>
 
#include <TObject.h>
 
#include <string>
 
class TClonesArray;
 
namespace Belle2 {
  namespace _RelationsInterfaceImpl {
    std::string htmlToPlainText(const std::string& html);
  };
 
  template <class BASE> class RelationsInterface: public BASE {
    static_assert(std::is_same<TObject, BASE>::value,
                  "Using RelationsInterface<BASE> is no longer allowed. Please use RelationsObject as a base class.");
  public:
    RelationsInterface(): m_cacheDataStoreEntry(NULL), m_cacheArrayIndex(-1) {}
 
    template<class ...Args> explicit RelationsInterface(Args&& ... params):
      BASE(std::forward<Args>(params)...),
      m_cacheDataStoreEntry(NULL), m_cacheArrayIndex(-1) { }
 
    RelationsInterface(const RelationsInterface& relationsInterface):
      BASE(relationsInterface),
      m_cacheDataStoreEntry(NULL), m_cacheArrayIndex(-1) { }
 
    RelationsInterface& operator=(const RelationsInterface& relationsInterface)
    {
      if (this != &relationsInterface)
        this->BASE::operator=(relationsInterface);
      return *this;
    }
 
 
    void addRelationTo(const RelationsInterface<BASE>* object, float weight = 1.0, const std::string& namedRelation = "") const
    {
      if (object)
        DataStore::Instance().addRelation(this, m_cacheDataStoreEntry, m_cacheArrayIndex,
                                          object, object->m_cacheDataStoreEntry, object->m_cacheArrayIndex, weight, namedRelation);
    }
 
    void addRelationTo(const TObject* object, float weight = 1.0, const std::string& namedRelation = "") const
    {
      StoreEntry* toEntry = nullptr;
      int toIndex = -1;
      DataStore::Instance().addRelation(this, m_cacheDataStoreEntry, m_cacheArrayIndex, object, toEntry, toIndex, weight, namedRelation);
    }
 
    void copyRelations(const RelationsInterface<BASE>* sourceObj)
    {
      if (!sourceObj)
        return;
      auto fromRels = sourceObj->getRelationsFrom<RelationsInterface<BASE>>("ALL");
      for (unsigned int iRel = 0; iRel < fromRels.size(); iRel++) {
        fromRels.object(iRel)->addRelationTo(this, fromRels.weight(iRel));
      }
 
      auto toRels = sourceObj->getRelationsTo<RelationsInterface<BASE>>("ALL");
      for (unsigned int iRel = 0; iRel < toRels.size(); iRel++) {
        this->addRelationTo(toRels.object(iRel), toRels.weight(iRel));
      }
    }
 
    //===========================================================================
    //These return a vector of relations:
 
    template <class TO> RelationVector<TO> getRelationsTo(const std::string& name = "", const std::string& namedRelation = "") const
    {
      return RelationVector<TO>(DataStore::Instance().getRelationsWith(DataStore::c_ToSide, this, m_cacheDataStoreEntry,
                                m_cacheArrayIndex, TO::Class(), name, namedRelation));
    }
 
    template <class FROM> RelationVector<FROM> getRelationsFrom(const std::string& name = "",
                                                                const std::string& namedRelation = "") const
    {
      return RelationVector<FROM>(DataStore::Instance().getRelationsWith(DataStore::c_FromSide, this, m_cacheDataStoreEntry,
                                  m_cacheArrayIndex, FROM::Class(), name, namedRelation));
    }
 
    template <class T> RelationVector<T> getRelationsWith(const std::string& name = "", const std::string& namedRelation = "") const
    {
      return RelationVector<T>(DataStore::Instance().getRelationsWith(DataStore::c_BothSides, this, m_cacheDataStoreEntry,
                               m_cacheArrayIndex, T::Class(), name, namedRelation));
    }
 
    //===========================================================================
    //These return only the first related object
 
    template <class TO> TO* getRelatedTo(const std::string& name = "", const std::string& namedRelation = "") const
    {
      return static_cast<TO*>(DataStore::Instance().getRelationWith(DataStore::c_ToSide, this, m_cacheDataStoreEntry, m_cacheArrayIndex,
                              TO::Class(), name, namedRelation).object);
    }
 
    template <class FROM> FROM* getRelatedFrom(const std::string& name = "", const std::string& namedRelation = "") const
    {
      return static_cast<FROM*>(DataStore::Instance().getRelationWith(DataStore::c_FromSide, this, m_cacheDataStoreEntry,
                                m_cacheArrayIndex, FROM::Class(), name, namedRelation).object);
    }
 
    template <class T> T* getRelated(const std::string& name = "", const std::string& namedRelation = "") const
    {
      return static_cast<T*>(DataStore::Instance().getRelationWith(DataStore::c_BothSides, this, m_cacheDataStoreEntry, m_cacheArrayIndex,
                             T::Class(), name, namedRelation).object);
    }
 
 
    //===========================================================================
    //These return an object/weight pair
 
    template <class TO> std::pair<TO*, float> getRelatedToWithWeight(const std::string& name = "",
        const std::string& namedRelation = "") const
    {
      RelationEntry entry = DataStore::Instance().getRelationWith(DataStore::c_ToSide, this, m_cacheDataStoreEntry, m_cacheArrayIndex,
                                                                  TO::Class(), name, namedRelation);
      return std::make_pair(static_cast<TO*>(entry.object), entry.weight);
    }
 
    template <class FROM> std::pair<FROM*, float> getRelatedFromWithWeight(const std::string& name = "",
        const std::string& namedRelation = "") const
    {
      RelationEntry entry = DataStore::Instance().getRelationWith(DataStore::c_FromSide, this, m_cacheDataStoreEntry, m_cacheArrayIndex,
                                                                  FROM::Class(), name, namedRelation);
      return std::make_pair(static_cast<FROM*>(entry.object), entry.weight);
    }
 
    template <class T> std::pair<T*, float> getRelatedWithWeight(const std::string& name = "",
        const std::string& namedRelation = "") const
    {
      RelationEntry entry = DataStore::Instance().getRelationWith(DataStore::c_BothSides, this, m_cacheDataStoreEntry, m_cacheArrayIndex,
                                                                  T::Class(), name, namedRelation);
      return std::make_pair(static_cast<T*>(entry.object), entry.weight);
    }
 
 
    //===========================================================================
    // Information about this object (not strictly relation-related)
 
    virtual std::string getName() const { return ""; }
 
    virtual std::string getInfoHTML() const { return ""; }
 
    std::string getInfo() const
    {
      return _RelationsInterfaceImpl::htmlToPlainText(getInfoHTML());
    }
 
 
    std::string getArrayName() const
    {
      DataStore::Instance().findStoreEntry(this, m_cacheDataStoreEntry, m_cacheArrayIndex);
      return m_cacheDataStoreEntry ? m_cacheDataStoreEntry->name : "";
    }
 
 
    int getArrayIndex() const
    {
      DataStore::Instance().findStoreEntry(this, m_cacheDataStoreEntry, m_cacheArrayIndex);
      return m_cacheArrayIndex;
    }
 
 
#if defined(__CINT__) || defined(__ROOTCLING__) || defined(R__DICTIONARY_FILENAME)
 
    RelationVector<TObject> getRelationsTo(const std::string& name) const
    {
      return getRelationsTo<TObject>(name);
    }
    RelationVector<TObject> getRelationsFrom(const std::string& name) const
    {
      return getRelationsFrom<TObject>(name);
    }
    RelationVector<TObject> getRelationsWith(const std::string& name) const
    {
      return getRelationsWith<TObject>(name);
    }
    TObject* getRelatedTo(const std::string& name, const std::string& namedRelation = "") const { return getRelatedTo<TObject>(name, namedRelation); }
    TObject* getRelatedFrom(const std::string& name, const std::string& namedRelation = "") const { return getRelatedFrom<TObject>(name, namedRelation); }
    TObject* getRelated(const std::string& name, const std::string& namedRelation = "") const { return getRelated<TObject>(name, namedRelation); }
#endif
  protected:
 
    TClonesArray* getArrayPointer() const
    {
      DataStore::Instance().findStoreEntry(this, m_cacheDataStoreEntry, m_cacheArrayIndex);
      if (!m_cacheDataStoreEntry)
        return nullptr;
      return m_cacheDataStoreEntry->getPtrAsArray();
    }
 
  private:
 
    mutable DataStore::StoreEntry* m_cacheDataStoreEntry;  
 
    mutable int                    m_cacheArrayIndex;      
 
    friend class DataStore;
 
    //version 0 to disable streaming
    ClassDef(RelationsInterface, 0); 
  };
 
  typedef RelationsInterface<TObject> RelationsObject;
}