RelationArray Class Reference

Low-level class to create/modify relations between StoreArrays. More...

#include <RelationArray.h>

Inheritance diagram for RelationArray:

Collaboration diagram for RelationArray:

Classes
struct	Identity
	Struct for identity transformation on indices. More...
class	ReplaceMap
	Struct to replace indices based on a map-like container. More...
class	ReplaceVec
	Struct to replace indices based on a sequential container. More...

Public Types
enum	EConsolidationAction {   c_doNothing ,   c_negativeWeight ,   c_zeroWeight ,   c_deleteElement }
	Modification actions for the consolidate member. More...
typedef ObjArrayIterator< const TClonesArray, const RelationElement >	const_iterator
	STL-like const_iterator over the T objects (not T* ).
typedef RelationElement::index_type	index_type
	Typedef to simplify use of correct index_type.
typedef RelationElement::weight_type	weight_type
	Typedef to simplify use of correct weight_type.
typedef std::pair< index_type, bool >	consolidation_type
	Typedef declaring the return value of any consolidation mapping.

Public Member Functions
bool	create (bool replace=false)
	Create an empty relation array in the data store.
template<class FROM , class TO >
	RelationArray (const StoreArray< FROM > &from, const StoreArray< TO > &to, const std::string &name="", DataStore::EDurability durability=DataStore::c_Event)
	Constructor which takes both store arrays and performs some sanity checks on the relation.
	RelationArray (const AccessorParams &fromAccessor, const AccessorParams &toAccessor, DataStore::EDurability durability=DataStore::c_Event)
	Constructor with AccessorParams for from- and to-side.
	RelationArray (const std::string &name, DataStore::EDurability durability=DataStore::c_Event)
	Constructor which only accepts name and durability of the relation.
	~RelationArray ()
	Empty destructor.
bool	isValid () const
	Check whether the object was created.
	operator bool () const
	Check whether the object was created.
const RelationElement &	operator[] (int i) const
	Imitate array functionality.
int	getEntries () const
	Get the number of elements.
const AccessorParams &	getFromAccessorParams () const
	Return the AccessorParams the attached relation points from.
const AccessorParams &	getToAccessorParams () const
	Return the AccessorParams the attached relation points to.
bool	getModified () const
	Get modified flag of underlying container.
void	setModified (bool modified)
	Set modified flag of underlying container.
void	clear () override
	Clear all elements from the relation.
void	add (index_type from, index_type to, weight_type weight=1.0)
	Add a new element to the relation.
void	add (index_type from, const std::vector< index_type > &to, weight_type weight=1.0)
	Add a new element to the relation.
void	add (index_type from, const std::vector< index_type > &to, const std::vector< weight_type > &weights)
	Add a new element to the relation.
template<class InputIterator >
void	add (index_type from, const InputIterator &begin, const InputIterator &end)
	Add a new element to the relation.
void	consolidate ()
	Consolidate Relation Elements.
template<class FunctionFrom , class FunctionTo >
void	consolidate (const FunctionFrom &replaceFrom=FunctionFrom(), const FunctionTo &replaceTo=FunctionTo(), EConsolidationAction action=c_doNothing)
	Consolidate RelationElements.
const_iterator	begin () const
	Return const_iterator to first entry.
const_iterator	end () const
	Return const_iterator to last entry +1.
bool	registerInDataStore (DataStore::EStoreFlags storeFlags=DataStore::c_WriteOut)
	Register the object/array in the DataStore.
bool	registerInDataStore (const std::string &name, DataStore::EStoreFlags storeFlags=DataStore::c_WriteOut)
	Register the object/array in the DataStore.
bool	isRequired (const std::string &name="")
	Ensure this array/object has been registered previously.
bool	isOptional (const std::string &name="")
	Tell the DataStore about an optional input.
bool	assign (TObject *object, bool replace=false)
	Assign 'object' to this accessor.
const std::string &	getName () const
	Return name under which the object is saved in the DataStore.
DataStore::EDurability	getDurability () const
	Return durability with which the object is saved in the DataStore.
AccessorParams	getAccessorParams () const
	Return pair of name and durability under which stored object is saved.
virtual bool	operator== (const StoreAccessorBase &other) const
	Check if two store accessors point to the same object/array.
virtual bool	operator!= (const StoreAccessorBase &other) const
	Check if two store accessors point to a different object/array.
TClass *	getClass () const
	The underlying object's type.
bool	isArray () const
	Is this an accessor for an array?
bool	notWrittenOut () const
	Returns true if this object/array should not be saved by output modules.
std::string	readableName () const
	Convert this acessor into a readable string (for messages).

Protected Attributes
std::string	m_name
	Store name under which this object/array is saved.
DataStore::EDurability	m_durability
	Store durability under which the object/array is saved.
TClass *	m_class
	The underlying object's type.
bool	m_isArray
	Is this an accessor for an array?

Private Member Functions
	RelationArray (const AccessorParams &params)
	Constructor which accepts the AccessorParams of the relation.
RelationElement *	next ()
	Return address where the next RelationElement should be created.
void	checkRelation (const std::string &direction, const AccessorParams &array, const AccessorParams &rel) const
	Check that the AccessorParams stored in the relation and the one given to the constructor are the same.
void	ensureAttached () const
	Attach to relation, if necessary.
void	assertValid () const
	check that pointer exits, otherwise bail out.
void	assertCreated ()
	Create relation, if necessary.

Private Attributes
AccessorParams	m_accessorFrom
	Accessor params for from array.
AccessorParams	m_accessorTo
	Accessor params for to array.
RelationContainer **	m_relations
	Pointer that actually holds the relations.

Friends
template<class FROM , class TO >
class	RelationIndex
template<class FROM , class TO >
class	RelationIndexContainer

Detailed Description

Low-level class to create/modify relations between StoreArrays.

Relations connect objects stored in two StoreArrays with each other, with the possibility of n:n connections and individual weights.

Note

In almost all cases, you'll want to create/find relations using RelationsObject instead.

Creating new relations

Assuming you have two StoreArrays called 'particles' and 'cdcsimhits', you can use RelationArray to create relations between entries:

RelationArray particlesToCdchits(particles, cdcsimhits);
for(int iPart = 0; iPart < particles.getEntries(); iPart++) {
  //... create new hit 'myhit'
  cdcsimhits.appendNew(myhit);
  int cdcsimhitIdx = cdcsimhits.getEntries()-1; //index of last object stored
 
  //connect objects at indices iPart and cdcsimhitIdx
  particlesToCdchits.add(iPart, cdcsimhitIdx);
}

This example loops over the 'particles' array and might for example simulate the particles' interaction with the detector. New hits are added and also connected with the particles that created them.

As with other data store objects, you should register relations you want to store in your implementation of Module::initialize(), see StoreArray::registerRelationTo()

See also

RelationsObject for the main user interface to relations.

RelationIndex provides an low-levvel interface to quickly find objects related to a given FROM/TO side object.

The on-disk data structure is provided by RelationElement objects in a RelationContainer.

Definition at line 62 of file RelationArray.h.

Member Typedef Documentation

consolidation_type

typedef std::pair<index_type, bool> consolidation_type

Typedef declaring the return value of any consolidation mapping.

It contains the new index of the element and a bool which is true if the old element has been re-attributed and false if there was just an reordering.

Definition at line 88 of file RelationArray.h.

const_iterator

typedef ObjArrayIterator<const TClonesArray, const RelationElement> const_iterator

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

Definition at line 65 of file RelationArray.h.

index_type

typedef RelationElement::index_type index_type

Typedef to simplify use of correct index_type.

Definition at line 68 of file RelationArray.h.

weight_type

typedef RelationElement::weight_type weight_type

Typedef to simplify use of correct weight_type.

Definition at line 71 of file RelationArray.h.

Member Enumeration Documentation

EConsolidationAction

enum EConsolidationAction

Modification actions for the consolidate member.

Determines what is to be done with elements where the original element was re-attributed and not just reordered

Enumerator
c_doNothing	Do nothing, just treat it as reordering.
c_negativeWeight	Flip the sign of the weight to become negative if the original element got re-attributed.
c_zeroWeight	Set the weight of the relation to 0 if the original element got re-attributed.
c_deleteElement	Delete the whole relation element if the original element got re-attributed.

Definition at line 77 of file RelationArray.h.

                              {
      c_doNothing, 
      c_negativeWeight, 
      c_zeroWeight, 
      c_deleteElement 
    };

Constructor & Destructor Documentation

RelationArray() [1/4]

RelationArray ( const StoreArray< FROM > &  from, const StoreArray< TO > &  to, const std::string &  name = "", DataStore::EDurability  durability = DataStore::c_Event  )

inline

Constructor which takes both store arrays and performs some sanity checks on the relation.

If the relation already exists it will be checked that the relation really relates between the given StoreArrays

Parameters

from	StoreArray the relation points from
to	StoreArray the relation points to
name	Name of the relation. Default is to use the default name based on the StoreArrays
durability	Durability of the relation. If the durability is larger than the durability of the related StoreArrays, an error is raised.

Definition at line 178 of file RelationArray.h.

                                                                                                     :
      StoreAccessorBase(name.empty() ? DataStore::relationName(from.getName(), to.getName()) : name, durability,
                        RelationContainer::Class(), false),
      m_accessorFrom(from.getAccessorParams()),
      m_accessorTo(to.getAccessorParams()),
      m_relations(0)
    {
      if (m_accessorFrom.second > m_durability || m_accessorTo.second > m_durability) {
        B2FATAL("Tried to create RelationArray '" << m_name << "' with a durability larger than the StoreArrays it relates");
      }
    }

RelationArray() [2/4]

RelationArray ( const AccessorParams &  fromAccessor, const AccessorParams &  toAccessor, DataStore::EDurability  durability = DataStore::c_Event  )

inline

Constructor with AccessorParams for from- and to-side.

Parameters

fromAccessor	(name, durability) of from side array
toAccessor	(name, durability) of to side array
durability	Durability of the relation. If the durability is larger than the durability of the related StoreArrays, an error is raised.

Definition at line 198 of file RelationArray.h.

                                                                     :
      StoreAccessorBase(DataStore::relationName(fromAccessor.first, toAccessor.first), durability, RelationContainer::Class(), false),
      m_accessorFrom(fromAccessor),
      m_accessorTo(toAccessor),
      m_relations(nullptr)
    {
      if (m_accessorFrom.second > m_durability || m_accessorTo.second > m_durability) {
        B2FATAL("Tried to create RelationArray '" << m_name << "' with a durability larger than the StoreArrays it relates");
      }
    }

RelationArray() [3/4]

RelationArray ( const std::string &  name, DataStore::EDurability  durability = DataStore::c_Event  )

inlineexplicit

Constructor which only accepts name and durability of the relation.

This constructor will only assign existing relations and will not create new ones since it lacks the information on the StoreArrays to relate

Parameters

name	Name of the (existing) Relation
durability	Durability of the (existing) Relation

Definition at line 218 of file RelationArray.h.

                                                                                                     :
      StoreAccessorBase(name, durability, RelationContainer::Class(), false),
      m_relations(0)
    {
      if (name.empty()) {
        B2FATAL("Cannot guess relation name, please supply correct name");
      }
    }

~RelationArray()

~RelationArray ( )

inline

Empty destructor.

Definition at line 228 of file RelationArray.h.

{}

RelationArray() [4/4]

RelationArray ( const AccessorParams &  params )

inlineexplicitprivate

Constructor which accepts the AccessorParams of the relation.

This constructor will only assign existing relations and will not create new ones since it lacks the information on the StoreArrays to relate

Parameters

params

AccessorParams for the (existing) Relation

Definition at line 381 of file RelationArray.h.

                                                        :
      StoreAccessorBase(params.first, params.second, RelationContainer::Class(), false),
      m_relations(0)
    {
      if (params.first.empty()) {
        B2FATAL("Cannot guess relation name, please supply correct name");
      }
    }

Member Function Documentation

add() [1/4]

void add ( index_type  from, const InputIterator &  begin, const InputIterator &  end  )

inline

Add a new element to the relation.

Parameters

from	index to point from
begin	iterator pointing to the begin of a sequence of std::pair<index_type,weight_type> or compatible
end	iterator pointing to the end of a sequence of std::pair<index_type,weight_type> or compatible

Definition at line 320 of file RelationArray.h.

    {
      setModified(true);
      new (next()) RelationElement(from, begin, end);
    }

add() [2/4]

void add ( index_type  from, const std::vector< index_type > &  to, const std::vector< weight_type > &  weights  )

inline

Add a new element to the relation.

Parameters

from	index to point from
to	indices to point to
weights	weights of the relations

Definition at line 306 of file RelationArray.h.

    {
      setModified(true);
      new (next()) RelationElement(from, to, weights);
    }

add() [3/4]

void add ( index_type  from, const std::vector< index_type > &  to, weight_type  weight = 1.0  )

inline

Add a new element to the relation.

Parameters

from	index to point from
to	indices to point to
weight	weight for all relations

Definition at line 293 of file RelationArray.h.

    {
      setModified(true);
      std::vector<weight_type> weights(to.size(), weight);
      new (next()) RelationElement(from, to, weights);
    }

add() [4/4]

void add ( index_type  from, index_type  to, weight_type  weight = 1.0  )

inline

Add a new element to the relation.

Parameters

from	index to point from
to	index to point to
weight	weight of the relation

Definition at line 281 of file RelationArray.h.

    {
      setModified(true);
      new (next()) RelationElement(from, to, weight);
    }

assertCreated()

void assertCreated ( )

inlineprivate

Create relation, if necessary.

After this function returns, the relation is guaranteed to be writeable.

Definition at line 442 of file RelationArray.h.

    {
      if (!isValid()) {
        if (!create()) {
          B2FATAL("Couldn't create relation " << m_name << "!");
        }
      }
    }

assertValid()

void assertValid ( ) const

inlineprivate

check that pointer exits, otherwise bail out.

Definition at line 436 of file RelationArray.h.

{ if (!isValid()) B2FATAL("RelationArray does not point to valid StoreObject"); }

assign()

bool assign ( TObject *  object, bool  replace = false  )

inherited

Assign 'object' to this accessor.

(takes ownership).

Parameters

object	The object that should be put in the DataStore, should be of same type as the one used by this accessor.
replace	Should an existing object be replaced? (if existing and supplied object are equal, this has no effect)

Returns

True if the assignment succeeded. If false, assign() will delete 'object', do not use it afterwards.

Definition at line 33 of file StoreAccessorBase.cc.

{
  if (not object)
    return false;
 
  bool success = false;
  const bool objIsArray = (object->IsA() == TClonesArray::Class());
  TClass* objClass = objIsArray ? (static_cast<TClonesArray*>(object))->GetClass() : object->IsA();
  if (objIsArray != isArray()) {
    B2ERROR("Cannot assign an object to an array (or vice versa); while assigning to " << readableName());
  } else if (objClass != getClass()) {
    B2ERROR("Cannot assign() an object of type '" << objClass->GetName() << "' to " << readableName() << " of type '" <<
            getClass()->GetName() << "'!");
  } else {
    success = DataStore::Instance().createObject(object, replace, *this);
  }
  if (!success)
    delete object;
  return success;
}

begin()

const_iterator begin ( ) const

inline

Return const_iterator to first entry.

Definition at line 369 of file RelationArray.h.

{ assertValid(); return const_iterator((*m_relations)->elements(), 0); }

checkRelation()

void checkRelation ( const std::string &  direction, const AccessorParams &  array, const AccessorParams &  rel  ) const

inlineprivate

Check that the AccessorParams stored in the relation and the one given to the constructor are the same.

Definition at line 399 of file RelationArray.h.

    {
      if (array.second == 0 && array.first.empty())
        return; //no information to check against...
 
      if (array != rel) {
        B2FATAL("Relation '" << m_name << "' exists but points " << direction << " wrong array:"
                << " requested " << array.first << "(" << array.second << ")"
                << ", got " << rel.first << "(" << rel.second << ")"
               );
      }
    }

clear()

void clear ( )

inlineoverridevirtual

Clear all elements from the relation.

Reimplemented from StoreAccessorBase.

Definition at line 269 of file RelationArray.h.

    {
      setModified(true);
      (*m_relations)->elements().Delete();
    }

consolidate()

void consolidate ( )

inline

Consolidate Relation Elements.

This function will loop over the relation and "compress" it by merging all elements with the same fromIndex.

Definition at line 331 of file RelationArray.h.

{ consolidate<Identity, Identity>(); }

create()

bool create ( bool  replace = false )

inline

Create an empty relation array in the data store.

Parameters

replace

Should an existing object be replaced?

Returns

True if the creation succeeded.

Definition at line 153 of file RelationArray.h.

    {
      bool result = DataStore::Instance().createObject(0, replace, *this);
      m_relations = reinterpret_cast<RelationContainer**>(DataStore::Instance().getObject(*this));
      if (result) {
        (*m_relations)->setFromName(m_accessorFrom.first);
        (*m_relations)->setFromDurability(m_accessorFrom.second);
        (*m_relations)->setToName(m_accessorTo.first);
        (*m_relations)->setToDurability(m_accessorTo.second);
      }
      return result;
    }

end()

const_iterator end ( ) const

inline

Return const_iterator to last entry +1.

Definition at line 371 of file RelationArray.h.

{ assertValid(); return const_iterator((*m_relations)->elements(), getEntries()); }

ensureAttached()

void ensureAttached ( ) const

inlineprivate

Attach to relation, if necessary.

Definition at line 413 of file RelationArray.h.

    {
      if (m_relations)
        return;
 
      const_cast<RelationArray*>(this)->m_relations = reinterpret_cast<RelationContainer**>(DataStore::Instance().getObject(*this));
      if (m_relations && *m_relations && !(*m_relations)->isDefaultConstructed()) {
        AccessorParams fromAccessorRel((*m_relations)->getFromName(), (DataStore::EDurability)(*m_relations)->getFromDurability());
        AccessorParams toAccessorRel((*m_relations)->getToName(), (DataStore::EDurability)(*m_relations)->getToDurability());
        //set if unset
        if (m_accessorFrom.first.empty())
          const_cast<RelationArray*>(this)->m_accessorFrom = fromAccessorRel;
        if (m_accessorTo.first.empty())
          const_cast<RelationArray*>(this)->m_accessorTo = toAccessorRel;
        checkRelation("from", m_accessorFrom, fromAccessorRel);
        checkRelation("to", m_accessorTo, toAccessorRel);
      } else {
        //no relation found, mark as invalid
        const_cast<RelationArray*>(this)->m_relations = nullptr;
      }
    }

getAccessorParams()

AccessorParams getAccessorParams ( ) const

inlineinherited

Return pair of name and durability under which stored object is saved.

Definition at line 134 of file StoreAccessorBase.h.

{ return make_pair(m_name, m_durability);}

getClass()

TClass * getClass ( ) const

inlineinherited

The underlying object's type.

Definition at line 149 of file StoreAccessorBase.h.

{ return m_class; }

getDurability()

DataStore::EDurability getDurability ( ) const

inlineinherited

Return durability with which the object is saved in the DataStore.

Definition at line 131 of file StoreAccessorBase.h.

{ return m_durability; }

getEntries()

int getEntries ( ) const

inline

Get the number of elements.

Definition at line 242 of file RelationArray.h.

{ return isValid() ? ((*m_relations)->getEntries()) : 0; }

getFromAccessorParams()

const AccessorParams & getFromAccessorParams ( ) const

inline

Return the AccessorParams the attached relation points from.

Definition at line 245 of file RelationArray.h.

    {
      ensureAttached();
      if (m_accessorFrom.first.empty())
        B2FATAL("trying to get accessor params from non-existing relation (this is likely a framework bug)");
      return m_accessorFrom;
    }

getModified()

bool getModified ( ) const

inline

Get modified flag of underlying container.

Definition at line 263 of file RelationArray.h.

{ assertValid(); return (*m_relations)->getModified(); }

getName()

const std::string & getName ( ) const

inlineinherited

Return name under which the object is saved in the DataStore.

Definition at line 128 of file StoreAccessorBase.h.

{ return m_name; }

getToAccessorParams()

const AccessorParams & getToAccessorParams ( ) const

inline

Return the AccessorParams the attached relation points to.

Definition at line 254 of file RelationArray.h.

    {
      ensureAttached();
      if (m_accessorTo.first.empty())
        B2FATAL("trying to get accessor params from non-existing relation (this is likely a framework bug)");
      return m_accessorTo;
    }

isArray()

bool isArray ( ) const

inlineinherited

Is this an accessor for an array?

Definition at line 152 of file StoreAccessorBase.h.

{ return m_isArray; }

isOptional()

bool isOptional ( const std::string &  name = "" )

inlineinherited

Tell the DataStore about an optional input.

Mainly useful for creating diagrams of module inputs and outputs.

Parameters

name	If not empty, set non-default name for this object/array. This is permanent, so that e.g. after using registerInDataStore("myName") in initialize(), this object will continue refer to 'myName' in event().

Returns

True if the object/array exists.

Definition at line 93 of file StoreAccessorBase.h.

    {
      if (!name.empty())
        m_name = name;
      return DataStore::Instance().optionalInput(*this);
    }

isRequired()

bool isRequired ( const std::string &  name = "" )

inlineinherited

Ensure this array/object has been registered previously.

Will cause an ERROR if it does not exist. This must be called in the initialization phase.

Parameters

name	If not empty, set non-default name for this object/array. This is permanent, so that e.g. after using registerInDataStore("myName") in initialize(), this object will continue refer to 'myName' in event().

Returns

True if the object/array exists.

Definition at line 78 of file StoreAccessorBase.h.

    {
      if (!name.empty())
        m_name = name;
      return DataStore::Instance().requireInput(*this);
    }

isValid()

bool isValid ( ) const

inline

Check whether the object was created.

Returns

True if the object exists.

Definition at line 234 of file RelationArray.h.

{ ensureAttached(); return m_relations && *m_relations;}

next()

RelationElement * next ( )

inlineprivate

Return address where the next RelationElement should be created.

Definition at line 392 of file RelationArray.h.

    {
      int index = (*m_relations)->elements().GetLast() + 1;
      return static_cast<RelationElement*>((*m_relations)->elements().AddrAt(index));
    }

notWrittenOut()

bool notWrittenOut ( ) const

inherited

Returns true if this object/array should not be saved by output modules.

See DataStore::c_DontWriteOut. Can be changed by re-registering it with/without the flag.

Definition at line 53 of file StoreAccessorBase.cc.

{
  const DataStore::StoreEntry* entry = DataStore::Instance().getEntry(*this);
  if (!entry) {
    B2ERROR("notWrittenOut(): " << readableName() << " doesn't seem to  be registered");
    return false;
  }
  return entry->dontWriteOut;
}

operator bool()

operator bool ( ) const

inline

Check whether the object was created.

Definition at line 236 of file RelationArray.h.

{ return isValid(); }

operator!=()

virtual bool operator!= ( const StoreAccessorBase &  other ) const

inlinevirtualinherited

Check if two store accessors point to a different object/array.

Definition at line 143 of file StoreAccessorBase.h.

    {
      return !(*this == other);
    }

operator==()

virtual bool operator== ( const StoreAccessorBase &  other ) const

inlinevirtualinherited

Check if two store accessors point to the same object/array.

Definition at line 137 of file StoreAccessorBase.h.

    {
      return getAccessorParams() == other.getAccessorParams();
    }

operator[]()

const RelationElement & operator[] ( int  i ) const

inline

Imitate array functionality.

Definition at line 239 of file RelationArray.h.

{ assertValid(); return (*m_relations)->getElement(i);}

readableName()

std::string readableName ( ) const

inherited

Convert this acessor into a readable string (for messages).

e.g. "object EventMetaData (durability: event)"

Definition at line 18 of file StoreAccessorBase.cc.

{
  std::string str(isArray() ? "array" : "object");
  str += " '" + getName() + "' (durability: ";
  switch (getDurability()) {
    case DataStore::c_Event:
      str += "event";
      break;
    case DataStore::c_Persistent:
      str += "persistent";
      break;
  }
  return str + ")";
}

registerInDataStore() [1/2]

bool registerInDataStore ( const std::string &  name, DataStore::EStoreFlags  storeFlags = DataStore::c_WriteOut  )

inlineinherited

Register the object/array in the DataStore.

This must be called in the initialization phase.

Parameters

name	If not empty, set non-default name for this object/array. This is permanent, so that e.g. after using registerInDataStore("myName") in initialize(), this object will continue refer to 'myName' in event().
storeFlags	ORed combination of DataStore::EStoreFlags.

Returns

True if the registration succeeded.

Definition at line 64 of file StoreAccessorBase.h.

    {
      if (!name.empty())
        m_name = name;
      return DataStore::Instance().registerEntry(m_name, m_durability, getClass(), isArray(), storeFlags);
    }

registerInDataStore() [2/2]

bool registerInDataStore ( DataStore::EStoreFlags  storeFlags = DataStore::c_WriteOut )

inlineinherited

Register the object/array in the DataStore.

This must be called in the initialization phase.

Parameters

storeFlags

ORed combination of DataStore::EStoreFlags.

Returns

True if the registration succeeded.

Definition at line 52 of file StoreAccessorBase.h.

    {
      return DataStore::Instance().registerEntry(m_name, m_durability, getClass(), isArray(), storeFlags);
    }

setModified()

void setModified ( bool  modified )

inline

Set modified flag of underlying container.

Definition at line 266 of file RelationArray.h.

{ assertCreated(); (*m_relations)->setModified(modified); }

Friends And Related Function Documentation

RelationIndex

friend class RelationIndex

friend

Definition at line 460 of file RelationArray.h.

RelationIndexContainer

friend class RelationIndexContainer

friend

Definition at line 461 of file RelationArray.h.

Member Data Documentation

m_accessorFrom

AccessorParams m_accessorFrom

private

Accessor params for from array.

Definition at line 452 of file RelationArray.h.

m_accessorTo

AccessorParams m_accessorTo

private

Accessor params for to array.

Definition at line 455 of file RelationArray.h.

m_class

TClass* m_class

protectedinherited

The underlying object's type.

Definition at line 172 of file StoreAccessorBase.h.

m_durability

DataStore::EDurability m_durability

protectedinherited

Store durability under which the object/array is saved.

Definition at line 169 of file StoreAccessorBase.h.

m_isArray

bool m_isArray

protectedinherited

Is this an accessor for an array?

Definition at line 175 of file StoreAccessorBase.h.

m_name

std::string m_name

protectedinherited

Store name under which this object/array is saved.

Definition at line 166 of file StoreAccessorBase.h.

m_relations

RelationContainer** m_relations

private

Pointer that actually holds the relations.

Definition at line 458 of file RelationArray.h.

---

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

• framework/datastore/include/RelationArray.h