RelationVector< T > Class Template Reference

Class for type safe access to objects that are referred to in relations. More...

#include <RelationVector.h>

Inheritance diagram for RelationVector< T >:

Collaboration diagram for RelationVector< T >:

Public Types
typedef ArrayIterator< RelationVector< T >, T >	iterator
	STL-like iterator over the T objects (not T* ).
typedef ArrayIterator< RelationVector< T >, const T >	const_iterator
	STL-like const_iterator over the T objects (not T* ).

Public Member Functions
	RelationVector (const RelationVectorBase &b)
	Constructor.
const std::vector< Belle2::RelationEntry > &	relations () const
	Accessor for the relations vector.
size_t	size () const
	Get number of relations.
T *	object (int index) const
	Get object with index.
T *	operator[] (int index) const
	Get object with index.
float	weight (int index) const
	Get weight with index.
void	remove (int index)
	Remove relation at given index.
void	setWeight (int index, float weight)
	Set a new weight for the given relation.
iterator	begin ()
	Return iterator to first entry.
iterator	end ()
	Return iterator to last entry +1.
const_iterator	begin () const
	Return const_iterator to first entry.
const_iterator	end () const
	Return const_iterator to last entry +1.

Protected Member Functions
void	add (const RelationVectorBase &other)
	add another list of relations.
void	apply (int index, const std::function< void(std::vector< unsigned int > &, std::vector< float > &, size_t)> &f)
	apply function to the relation associated with the RelationEntry at given index.

Protected Attributes
std::string	m_name
	entry name of array containing object these relations belong to.
int	m_index { -1}
	index of object these relations belong to.
std::vector< RelationEntry >	m_relations
	The vector of relation entries.
std::vector< std::string >	m_relationNames
	Names of associated relations.

Detailed Description

template<class T>
class Belle2::RelationVector< T >

Class for type safe access to objects that are referred to in relations.

Objects of this class are returned by RelationsObject functinons to provide type safe access to the objects in a vector of relations returned by the data store.

Besides accessing objects/weights directly using operator[](int) and weight(int), you can also iterate over the objects directly:

const MCParticle* particle = particles[i];
for (const CDCSimHit& simhit :  particle->getRelationsTo<CDCSimHit>()) {
  //do things with simhit
}

If you want to modify the related objects in the loop body, you can use a non-const reference instead.

Use setWeight() to modify the weight of a single relation. Use remove() to delete a relation.

Definition at line 67 of file RelationVector.h.

Member Typedef Documentation

const_iterator

typedef ArrayIterator<RelationVector<T>, const T> const_iterator

STL-like const_iterator over the T objects (not T* ).

Definition at line 72 of file RelationVector.h.

iterator

typedef ArrayIterator<RelationVector<T>, T> iterator

STL-like iterator over the T objects (not T* ).

Definition at line 70 of file RelationVector.h.

Constructor & Destructor Documentation

RelationVector()

RelationVector ( const RelationVectorBase &  b )

inlineexplicit

Constructor.

Parameters

b	Not type-safe base class containing the data

Definition at line 79 of file RelationVector.h.

: RelationVectorBase(b) {}

Member Function Documentation

add()

void add ( const RelationVectorBase &  other )

protectedinherited

add another list of relations.

(internal use)

Definition at line 59 of file RelationVector.cc.

{
  if ((other.m_name != m_name) or (other.m_index != m_index))
    B2FATAL("Trying to add RelationVectorBase for " << m_name << m_index << " and " << other.m_name << other.m_index << "!");
 
  m_relations.insert(m_relations.end(), other.m_relations.begin(), other.m_relations.end());
  if (!other.m_relations.empty())
    m_relationNames.insert(m_relationNames.end(), other.m_relationNames.begin(), other.m_relationNames.end());
}

apply()

void apply ( int  index, const std::function< void(std::vector< unsigned int > &, std::vector< float > &, size_t)> &  f  )

protectedinherited

apply function to the relation associated with the RelationEntry at given index.

Definition at line 13 of file RelationVector.cc.

{
  const TObject* obj = m_relations.at(index).object;
  float objweight = m_relations.at(index).weight;
 
  for (const auto& name : m_relationNames) {
    RelationArray rel(name, DataStore::c_Event);
 
    //fill fromIndex, toIndex the rght way around
    unsigned int fromIndex, toIndex;
    StoreEntry* entry = nullptr;
    int otherIndex = -1;
    if (!DataStore::Instance().findStoreEntry(obj, entry, otherIndex))
      B2FATAL("RelationVectorBase points to object not in DataStore?");
 
    if (m_name == rel.getFromAccessorParams().first and entry->name == rel.getToAccessorParams().first) {
      fromIndex = m_index;
      toIndex = otherIndex;
    } else if (entry->name == rel.getFromAccessorParams().first and m_name == rel.getToAccessorParams().first) {
      toIndex = m_index;
      fromIndex = otherIndex;
    } else {
      continue;
    }
 
    //go through rel, see if we can find fromIndex and toIndex
    for (int i = 0; i < rel.getEntries(); i++) {
      if (rel[i].getFromIndex() == fromIndex) {
        auto& toIndices = const_cast<std::vector<RelationElement::index_type>&>(rel[i].getToIndices());
        auto& toWeights = const_cast<std::vector<RelationElement::weight_type>&>(rel[i].getWeights());
        for (size_t j = 0; j < toIndices.size(); j++) {
          //we also compare the weight here to handle duplicate relations properly
          if (toIndices[j] == toIndex and toWeights[j] == objweight) {
            f(toIndices, toWeights, j);
            rel.setModified(true);
            return;
          }
        }
      }
    }
  }
 
  B2FATAL("RelationVectorBase and DataStore differ!??");
}

begin() [1/2]

iterator begin ( )

inline

Return iterator to first entry.

Definition at line 141 of file RelationVector.h.

{ return iterator(this, 0); }

begin() [2/2]

const_iterator begin ( ) const

inline

Return const_iterator to first entry.

Definition at line 146 of file RelationVector.h.

{ return const_iterator(this, 0); }

end() [1/2]

iterator end ( )

inline

Return iterator to last entry +1.

Definition at line 143 of file RelationVector.h.

{ return iterator(this, size()); }

end() [2/2]

const_iterator end ( ) const

inline

Return const_iterator to last entry +1.

Definition at line 148 of file RelationVector.h.

{ return const_iterator(this, size()); }

object()

T * object ( int  index ) const

inline

Get object with index.

Parameters

index

Index of relation.

Returns

Object that the relation points to.

Definition at line 96 of file RelationVector.h.

{return static_cast<T*>(m_relations[index].object);}

operator[]()

T * operator[] ( int  index ) const

inline

Get object with index.

Parameters

index

Index of relation.

Returns

Object that the relation points to.

Definition at line 103 of file RelationVector.h.

{return object(index);}

relations()

const std::vector< Belle2::RelationEntry > & relations ( ) const

inline

Accessor for the relations vector.

Returns

Vector of RelationEntry objects.

Definition at line 85 of file RelationVector.h.

{return m_relations;}

remove()

void remove ( int  index )

inline

Remove relation at given index.

This will decrease size() by one. Iterators pointing beyond given index will be invalidated when calling this function.

Note

May be slow if done frequently.

Definition at line 119 of file RelationVector.h.

    {
      apply(index, [](std::vector<unsigned int>& indices, std::vector<float>& weights,
      size_t elidx) {
        indices.erase(indices.begin() + elidx);
        weights.erase(weights.begin() + elidx);
      });
 
      m_relations.erase(m_relations.begin() + index);
    }

setWeight()

void setWeight ( int  index, float  weight  )

inline

Set a new weight for the given relation.

Definition at line 131 of file RelationVector.h.

    {
      apply(index, [weight](std::vector<unsigned int>&, std::vector<float>& weights, size_t elidx) {
        weights[elidx] = weight;
      });
 
      m_relations[index].weight = weight;
    }

size()

size_t size ( ) const

inline

Get number of relations.

Definition at line 88 of file RelationVector.h.

{ return m_relations.size();}

weight()

float weight ( int  index ) const

inline

Get weight with index.

Parameters

index

Index of relation.

Returns

Weight that the relation has.

Definition at line 110 of file RelationVector.h.

{return m_relations[index].weight;}

Member Data Documentation

m_index

int m_index { -1}

protectedinherited

index of object these relations belong to.

Definition at line 41 of file RelationVector.h.

m_name

std::string m_name

protectedinherited

entry name of array containing object these relations belong to.

Definition at line 40 of file RelationVector.h.

m_relationNames

std::vector<std::string> m_relationNames

protectedinherited

Names of associated relations.

Definition at line 43 of file RelationVector.h.

m_relations

std::vector<RelationEntry> m_relations

protectedinherited

The vector of relation entries.

Definition at line 42 of file RelationVector.h.

---

The documentation for this class was generated from the following files:

• framework/datastore/include/DataStore.h
• framework/datastore/include/RelationVector.h