#include <SafePointer.hh>

Collaboration diagram for TPEF::ReferenceManager::SafePointer:

Public Member Functions
virtual	~SafePointer ()

SafePointable *	pointer () const

void	setPointer (SafePointable *object)

Static Public Member Functions
static bool	isAlive (SafePointer *pointerToCheck)

static bool	isReferenced (const SafePointable *object)

static void	addObjectReference (SectionIndexKey key, const SafePointable *obj)

static void	addObjectReference (SectionOffsetKey key, const SafePointable *obj)

static void	addObjectReference (FileOffsetKey key, const SafePointable *obj)

static void	addObjectReference (SectionKey key, const SafePointable *obj)

static SectionIndexKey	sectionIndexKeyFor (const SafePointable *obj)

static SectionOffsetKey	sectionOffsetKeyFor (const SafePointable *obj)

static FileOffsetKey	fileOffsetKeyFor (const SafePointable *obj)

static SectionKey	sectionKeyFor (const SafePointable *obj)

static void	notifyDeleted (const SafePointable *obj)

static void	notifyDeleted (SafePointer *safePointer)

static void	resolve ()

static void	cleanupKeyTables ()

static void	cleanup ()

template<typename MapType >
static bool	unresolvedReferences (const MapType &mapToCheck, const ReferenceKey **unresolvedKey)

static const SafePointer *	replaceReference (const SafePointer old, SafePointable obj)

static void	replaceAllReferences (SafePointable newObj, SafePointable oldObj)

template<typename ObjType >
static SafePointer *	genericCreate (ObjType obj)

Static Public Attributes
static const SafePointer	null
	The default SafePointer that is used in null references. More...

Protected Member Functions
	SafePointer (SectionIndexKey key)

	SafePointer (SectionOffsetKey key)

	SafePointer (FileOffsetKey key)

	SafePointer (SectionKey key)

	SafePointer (SafePointable *object)

template<typename KeyType , typename MapType >
void	genericRegisterPointer (const KeyType &key, MapType &destinationMap, SafePointer *newSafePointer)

Static Protected Member Functions
template<typename KeyType , typename MapType >
static void	genericAddObjectReference (const KeyType &key, MapType &destinationMap, const SafePointable *obj)

template<typename KeyType , typename MapType >
static KeyType	genericKeyFor (const SafePointable *obj, MapType &sourceMap)

template<typename MapType >
static void	safelyCleanupKeyTable (MapType &sourceMap, std::set< SafePointerList * > &listsToDelete)

Private Types
typedef std::pair< const SafePointable , void >	KeyForCacheKey
	Key type for cache, void* is pointer to key map (sectioMap_, sectionOffsetMap, ...) More...

typedef std::map< KeyForCacheKey, const ReferenceKey * >	KeyForCacheMap

Private Member Functions
SafePointer &	operator= (SafePointer &)
	Assignment not allowed. More...

	SafePointer (SafePointer &)
	Copying not allowed. More...

Private Attributes
SafePointable *	object_
	The reference to the real object. More...

std::string	debugString_

Static Private Attributes
static SectionIndexMap *	sectionIndexMap_ = new SectionIndexMap
	Map of SafePointers that are requested using SectionIndexKeys. More...

static SectionOffsetMap *	sectionOffsetMap_ = new SectionOffsetMap
	Map of SafePointers that are requested using SectionOffsetKeys. More...

static FileOffsetMap *	fileOffsetMap_ = new FileOffsetMap
	Map of SafePointers that are requested using FileOffsetKeys. More...

static SectionMap *	sectionMap_ = new SectionMap
	Map of SafePointers that are requested using SectionKeys. More...

static ReferenceMap *	referenceMap_ = new ReferenceMap
	Map of SafePointers that have resolved references. More...

static SafePointerSet *	aliveSafePointers_ = new SafePointerSet
	Set that cointains all alive (not deleted) SafePointers for extra safety. More...

static KeyForCacheMap *	keyForCache_
	Map for cache. More...

Detailed Description

Indirection for object references.

Allows updating references later on, thus allows referencing objects that are created later. Helps with the dangling pointers problem, too.

References to objects that are not created yet are made with different kind of keys. These keys refer for example to sections and offsets in source binary file while reading the binary. After the binary is read and the object model of binary is constructed, these keys and keytables have no use.

Definition at line 188 of file SafePointer.hh.

Member Typedef Documentation

◆ KeyForCacheKey

typedef std::pair<const SafePointable*, void*> TPEF::ReferenceManager::SafePointer::KeyForCacheKey

private

Key type for cache, void* is pointer to key map (sectioMap_, sectionOffsetMap, ...)

Definition at line 339 of file SafePointer.hh.

◆ KeyForCacheMap

typedef std::map<KeyForCacheKey,const ReferenceKey*> TPEF::ReferenceManager::SafePointer::KeyForCacheMap

private

Definition at line 340 of file SafePointer.hh.

Constructor & Destructor Documentation

◆ ~SafePointer()

TPEF::ReferenceManager::SafePointer::~SafePointer ( )

virtual

Destructor.

Informs of deletion of itself to the reference manager.

Definition at line 256 of file SafePointer.cc.

                           {
     notifyDeleted(this);
 }

References notifyDeleted().

Here is the call graph for this function:

◆ SafePointer() [1/6]

TPEF::ReferenceManager::SafePointer::SafePointer ( SectionIndexKey key )

protected

Construct a SafePointer using SectionIndexKey.

Parameters

key	Key to use while requesting the reference.

Definition at line 199 of file SafePointer.cc.

                                             :
     object_(NULL) {
  
     genericRegisterPointer(key, *sectionIndexMap_, this);
 }

References genericRegisterPointer(), and sectionIndexMap_.

Here is the call graph for this function:

◆ SafePointer() [2/6]

TPEF::ReferenceManager::SafePointer::SafePointer ( SectionOffsetKey key )

protected

Construct a SafePointer using SectionOffsetKey.

Parameters

key	Key to use while requesting the reference.

Definition at line 210 of file SafePointer.cc.

                                              :
     object_(NULL) {
  
     genericRegisterPointer(key, *sectionOffsetMap_, this);
 }

References genericRegisterPointer(), and sectionOffsetMap_.

Here is the call graph for this function:

◆ SafePointer() [3/6]

TPEF::ReferenceManager::SafePointer::SafePointer ( FileOffsetKey key )

protected

Construct a SafePointer using FileOffsetKey.

Parameters

key	Key to use while requesting the reference.

Definition at line 221 of file SafePointer.cc.

                                           :
     object_(NULL) {
  
     genericRegisterPointer(key, *fileOffsetMap_, this);
 }

References fileOffsetMap_, and genericRegisterPointer().

Here is the call graph for this function:

◆ SafePointer() [4/6]

TPEF::ReferenceManager::SafePointer::SafePointer ( SectionKey key )

protected

Construct a SafePointer using section reference.

Parameters

key	Key object to use while requesting the reference.

Definition at line 232 of file SafePointer.cc.

                                        :
     object_(NULL) {
  
     genericRegisterPointer(key, *sectionMap_, this);
 }

References genericRegisterPointer(), and sectionMap_.

Here is the call graph for this function:

◆ SafePointer() [5/6]

TPEF::ReferenceManager::SafePointer::SafePointer ( SafePointable * object )

protected

Construct a SafePointer using object reference.

Parameters

object Object to use while requesting the reference.

Definition at line 243 of file SafePointer.cc.

                                               :
     object_(object) {
  
     if (object != NULL) {
         genericRegisterPointer(object, *referenceMap_, this);
     }
 }

References genericRegisterPointer(), and referenceMap_.

Here is the call graph for this function:

◆ SafePointer() [6/6]

TPEF::ReferenceManager::SafePointer::SafePointer ( SafePointer & )

private

Copying not allowed.

Member Function Documentation

◆ addObjectReference() [1/4]

void TPEF::ReferenceManager::SafePointer::addObjectReference	(	FileOffsetKey	key,
		const SafePointable *	obj
	)

static

Inform of a connection between a FileOffsetKey and an object.

Connects given key with object and sets possible old SafePointers connected with the key to point to this object.

Parameters

key	Key that the object is connected to.
obj	Pointer to the connected object.

Exceptions

KeyAlreadyExists If entry with given key already exists.

Definition at line 337 of file SafePointer.cc.

                                                                            {
     genericAddObjectReference(key, *fileOffsetMap_, obj);
 }

References fileOffsetMap_, and genericAddObjectReference().

Here is the call graph for this function:

◆ addObjectReference() [2/4]

void TPEF::ReferenceManager::SafePointer::addObjectReference	(	SectionIndexKey	key,
		const SafePointable *	obj
	)

static

Inform of a connection between a SectionIndexKey and an object.

Connects given key with object and sets possible old SafePointers connected with the key to point to this object.

Parameters

key	Key that the object is connected to.
obj	Pointer to the connected object.

Exceptions

KeyAlreadyExists If entry with given key already exists.

Definition at line 306 of file SafePointer.cc.

                                                                              {
     genericAddObjectReference(key, *sectionIndexMap_, obj);
 }

References genericAddObjectReference(), and sectionIndexMap_.

Here is the call graph for this function:

◆ addObjectReference() [3/4]

void TPEF::ReferenceManager::SafePointer::addObjectReference	(	SectionKey	key,
		const SafePointable *	obj
	)

static

Inform of a connection between a SectionKey and an object.

Connects given key with object and sets possible old SafePointers connected with the key to point to this object.

Parameters

key	Key that the object is connected to.
obj	Pointer to the connected object.

Exceptions

KeyAlreadyExists If entry with given key already exists.

Definition at line 352 of file SafePointer.cc.

                                                                         {
     genericAddObjectReference(key, *sectionMap_, obj);
 }

References genericAddObjectReference(), and sectionMap_.

Here is the call graph for this function:

◆ addObjectReference() [4/4]

void TPEF::ReferenceManager::SafePointer::addObjectReference	(	SectionOffsetKey	key,
		const SafePointable *	obj
	)

static

Inform of a connection between a SectionOffsetKey and an object.

Connects given key with object and sets possible old SafePointers connected with the key to point to this object.

Parameters

key	Key that the object is connected to.
obj	Pointer to the connected object.

Exceptions

KeyAlreadyExists If entry with given key already exists.

Definition at line 321 of file SafePointer.cc.

                                                     {
     genericAddObjectReference(key, *sectionOffsetMap_, obj);
 }

References genericAddObjectReference(), and sectionOffsetMap_.

Here is the call graph for this function:

◆ cleanup()

void TPEF::ReferenceManager::SafePointer::cleanup ( )

static

Frees all dynamically allocated memory consumed in reference managing.

Deletes all entires in all maps, safe pointer lists in them and all alive safe pointers. This method should be called in the destructor of Binary or in the end of the program.

Definition at line 667 of file SafePointer.cc.

                      {
  
     cleanupKeyTables();
     MapTools::deleteAllValues(*referenceMap_);
 }

References cleanupKeyTables(), MapTools::deleteAllValues(), and referenceMap_.

Referenced by TPEF::Binary::~Binary().

Here is the call graph for this function:

◆ cleanupKeyTables()

void TPEF::ReferenceManager::SafePointer::cleanupKeyTables ( )

static

Deletes all entries in all key maps, doesn't clean the ReferenceMap.

Deletes also the SafePointer lists found in the maps if they are not found in the reference map. Does not delete SafePointers. This can be called to free some needless resources after the object model of binary file is fully constructed, and resolve() is called without an exception.

Definition at line 644 of file SafePointer.cc.

                               {
  
     set<SafePointerList*> listsToDelete;
     safelyCleanupKeyTable(*sectionIndexMap_, listsToDelete);
     safelyCleanupKeyTable(*sectionOffsetMap_, listsToDelete);
     safelyCleanupKeyTable(*fileOffsetMap_, listsToDelete);
     safelyCleanupKeyTable(*sectionMap_, listsToDelete);
  
     AssocTools::deleteAllItems(listsToDelete);
  
     // clear keyForCache...
     keyForCache_->clear();
 }

References AssocTools::deleteAllItems(), fileOffsetMap_, keyForCache_, safelyCleanupKeyTable(), sectionIndexMap_, sectionMap_, and sectionOffsetMap_.

Referenced by cleanup(), TPEF::BinaryReader::readBinary(), and TPEF::BinaryWriter::writeBinary().

Here is the call graph for this function:

◆ fileOffsetKeyFor()

FileOffsetKey TPEF::ReferenceManager::SafePointer::fileOffsetKeyFor ( const SafePointable * obj )

static

Returns the FileOffsetKey connected to given object.

Returns: The key.

Parameters

obj	Object to look the key for.

Exceptions

KeyNotFound If the key cannot be found for the object.

Definition at line 394 of file SafePointer.cc.

                                                       {
     return genericKeyFor<FileOffsetKey>(obj, *fileOffsetMap_);
 }

References fileOffsetMap_.

Referenced by TPEF::FileOffsetReplacer::tryToReplace().

◆ genericAddObjectReference()

template<typename KeyType , typename MapType >

static void TPEF::ReferenceManager::SafePointer::genericAddObjectReference	(	const KeyType &	key,
		MapType &	destinationMap,
		const SafePointable *	obj
	)

staticprotected

Referenced by addObjectReference().

◆ genericCreate()

template<typename ObjType >

static SafePointer* TPEF::ReferenceManager::SafePointer::genericCreate ( ObjType obj )

static

◆ genericKeyFor()

template<typename KeyType , typename MapType >

static KeyType TPEF::ReferenceManager::SafePointer::genericKeyFor	(	const SafePointable *	obj,
		MapType &	sourceMap
	)

staticprotected

◆ genericRegisterPointer()

template<typename KeyType , typename MapType >

void TPEF::ReferenceManager::SafePointer::genericRegisterPointer	(	const KeyType &	key,
		MapType &	destinationMap,
		SafePointer *	newSafePointer
	)

protected

Referenced by SafePointer().

◆ isAlive()

bool TPEF::ReferenceManager::SafePointer::isAlive ( SafePointer * pointerToCheck )

static

Check if SafePointer is alive, that is it's not deleted yet.

Parameters

pointerToCheck The pointer to check.

Returns: True if SafePointer is alive.

Definition at line 267 of file SafePointer.cc.

                                                 {
  
     return
         (pointerToCheck != NULL &&
          AssocTools::containsKey(*aliveSafePointers_, pointerToCheck));
 }

References aliveSafePointers_, and AssocTools::containsKey().

Referenced by TPEF::ReferenceManager::SafePointerList::cleanupDead(), and TPEF::ReferenceManager::SafePointerList::setReference().

Here is the call graph for this function:

◆ isReferenced()

bool TPEF::ReferenceManager::SafePointer::isReferenced ( const SafePointable * object )

static

Check if object is referenced, that is reference manager is managing SafePointers that point to that object.

Parameters

object Object to check.

Returns: True if object is referenced.

Definition at line 282 of file SafePointer.cc.

                                                      {
  
     if (!MapTools::containsKey(*referenceMap_, object)) {
         return false;
     }
  
     SafePointerList* theList = (*referenceMap_)[object];
     theList->cleanupDead();
  
     return (theList->length() > 0);
 }

References TPEF::ReferenceManager::SafePointerList::cleanupDead(), MapTools::containsKey(), TPEF::ReferenceManager::SafePointerList::length(), and referenceMap_.

Referenced by TPEF::TPEFStringSectionWriter::actualWriteData(), TPEF::TPEFDataSectionWriter::actualWriteData(), TPEF::TPEFCodeSectionWriter::actualWriteData(), and TPEF::TPEFUDataSectionWriter::createKeys().

Here is the call graph for this function:

◆ notifyDeleted() [1/2]

void TPEF::ReferenceManager::SafePointer::notifyDeleted ( const SafePointable * obj )

static

Inform of deletion of an object.

All SafePointers that are pointing to the deleted object are set to NULL and the object's entry is removed from the ReferenceMap.

Parameters

obj	Deleted object.

Definition at line 421 of file SafePointer.cc.

                                                    {
  
     if (!MapTools::containsKey(*referenceMap_, obj)) {
         return;
     }
  
     SafePointerList *listOfObj = (*referenceMap_)[obj];
  
     assert(listOfObj != NULL);
     listOfObj->cleanup();
  
     // if the safe pointer list we just cleaned up is not referenced in any
     // map anymore, it can be deleted safely
  
     // TODO: for hashmap implementation this will take *very* long time
     //       so fix this before change typedefs in SafePointer.hh
     if (!MapTools::containsValue(*sectionMap_,       listOfObj) &&
         !MapTools::containsValue(*sectionIndexMap_,  listOfObj) &&
         !MapTools::containsValue(*sectionOffsetMap_, listOfObj) &&
         !MapTools::containsValue(*fileOffsetMap_,    listOfObj)) {
         delete listOfObj;
     }
  
     referenceMap_->erase(obj);
 }

References assert, TPEF::ReferenceManager::SafePointerList::cleanup(), MapTools::containsKey(), MapTools::containsValue(), fileOffsetMap_, referenceMap_, sectionIndexMap_, sectionMap_, and sectionOffsetMap_.

Referenced by TPEF::SafePointable::~SafePointable(), and ~SafePointer().

Here is the call graph for this function:

◆ notifyDeleted() [2/2]

void TPEF::ReferenceManager::SafePointer::notifyDeleted ( SafePointer * safePointer )

static

Inform of deletion of a SafePointer.

Removes SafePointer from the list of alive SafePointers.

Parameters

safePointer The deleted SafePointer.

Definition at line 455 of file SafePointer.cc.

                                                    {
  
     // the null safe pointer is an exception, it shouldn't be never deleted
     if (safePointer == &null) {
         return;
     }
  
     unsigned int pointersFound = 0;
     pointersFound = (*aliveSafePointers_).erase(safePointer);
     assert(pointersFound == 1);
 }

References assert.

◆ operator=()

SafePointer& TPEF::ReferenceManager::SafePointer::operator= ( SafePointer & )

private

Assignment not allowed.

◆ pointer()

SafePointable* TPEF::ReferenceManager::SafePointer::pointer ( ) const

Referenced by TPEF::LineNumSection::codeSection(), TPEF::DebugElement::debugString(), TPEF::ASpaceSection::isUndefined(), TPEF::DataSymElement::reference(), TPEF::CodeSymElement::reference(), and TPEF::ASpaceSection::undefinedASpace().

◆ replaceAllReferences()

static void TPEF::ReferenceManager::SafePointer::replaceAllReferences	(	SafePointable *	newObj,
		SafePointable *	oldObj
	)

static

Referenced by TPEF::AOutSymbolSectionReader::finalize().

◆ replaceReference()

static const SafePointer* TPEF::ReferenceManager::SafePointer::replaceReference	(	const SafePointer *	old,
		SafePointable *	obj
	)

static

Referenced by TPEF::LineNumSection::setCodeSection(), TPEF::DebugElement::setDebugString(), TPEF::DataSymElement::setReference(), TPEF::CodeSymElement::setReference(), and TPEF::ASpaceSection::setUndefinedASpace().

◆ resolve()

void TPEF::ReferenceManager::SafePointer::resolve ( )

static

Tries to resolve unresolved references.

Unreselved references are tried to be resolved by requesting a chunk with the section's chunk() method the reference points to. Chunks mean practically offset in the section and the size of the referenced data. If there's an unresolved reference to an offset in a section that can be chunked (section contains raw data), then we can create new elements using chunk() 'on demand'.

Exceptions

UnresolvedReference If unresolvable references are found.

Definition at line 480 of file SafePointer.cc.

                      {
     // try to resolve references in sectionOffsetMap
     for (SectionOffsetMap::iterator i = sectionOffsetMap_->begin();
          i != sectionOffsetMap_->end(); i++) {
  
         SectionOffsetKey key = (*i).first;
  
         SafePointerList* l = (*i).second;
         assert(l != NULL);
         SafePointable* object = l->reference();
  
         // if reference is resolved continue
         if (MapTools::containsKey(*referenceMap_, object)) {
             continue;
         }
  
         // there is no section with the identification code of the section
         // offset key
         if (!MapTools::containsKey(
                 *sectionMap_, SectionKey(key.sectionId()))) {
             std::stringstream errorMessage;
             errorMessage << "Cannot find section with identification code "
                          << key.sectionId() << " in the section map.";
  
 #ifndef NDEBUG
             errorMessage << " SafePointer created in : "
                          << l->front()->debugString();
 #endif
  
             throw UnresolvedReference(
                 __FILE__, __LINE__, __func__, errorMessage.str());
         }
  
         // try to get the pointer to the section to request chunk from
         SafePointerList* pointersToSection =
             (*sectionMap_)[SectionKey(key.sectionId())];
  
         assert(pointersToSection != NULL);
  
         Section* theSection =
             dynamic_cast<Section*>(pointersToSection->reference());
  
         if (theSection == NULL) {
             std::stringstream errorMessage;
             errorMessage << "Can't get section of reference pointed "
                          << "by SectionOffsetKey.";
  
 #ifndef NDEBUG
             errorMessage << " SafePointer created in : "
                          << l->front()->debugString();
 #endif
  
             throw UnresolvedReference(
                 __FILE__, __LINE__, __func__, errorMessage.str());
         }
  
         SafePointable* chunk = NULL;
         try {
             chunk =
                 static_cast<SafePointable*>(theSection->chunk(key.offset()));
  
         } catch (const NotChunkable& e) {
             // Probably there is some section that should be referred by 
             // section offsets but, while reading that section all necessary 
             // keys has not been stored.
             std::stringstream errorMessage;
             errorMessage << "Can't resolve section offset, because there"
                          << " no object stored stored for key sectionId: "
                          << key.sectionId() << " offset: " << key.offset();
 #ifndef NDEBUG
             errorMessage << " SafePointer created in : "
                          << l->front()->debugString();
 #endif
             throw UnresolvedReference(__FILE__,
                                       __LINE__,
                                       "SafePointer::resolve()",
                                       errorMessage.str());
         }
  
         assert(chunk != NULL);
         addObjectReference(key, chunk);
     }
  
     // check if key maps still contain unresolved references and 
     // give propriate error messages.
     std::stringstream errorMessage;
     const ReferenceKey *unresolvedKey = NULL;
     SafePointer *firstUnresolvedPointerOfList = NULL;
  
     if (unresolvedReferences(*sectionMap_, &unresolvedKey)) {
         const SectionKey *sectionKey =
             dynamic_cast<const SectionKey*>(unresolvedKey);
  
         errorMessage << "with section keys. Requested identification code: "
                      << sectionKey->sectionId() << std::endl;
  
         // get first of unresolved pointers in safe pointer list
         firstUnresolvedPointerOfList =
             (*sectionMap_->find(*sectionKey)).second->front();
     }
  
     if (unresolvedReferences(*sectionIndexMap_,  &unresolvedKey)) {
         const SectionIndexKey *indexKey =
             dynamic_cast<const SectionIndexKey*>(unresolvedKey);
  
         errorMessage << "Problem with section index keys. "
                      << "Requested section identification code: "
                      << static_cast<int>(indexKey->sectionId())
                      << " index: "
                      << indexKey->index() << std::endl;
  
         firstUnresolvedPointerOfList =
             (*sectionIndexMap_->find(*indexKey)).second->front();
     }
  
     if (unresolvedReferences(*sectionOffsetMap_,  &unresolvedKey)) {
  
         const SectionOffsetKey *sectionOffsetKey =
             dynamic_cast<const SectionOffsetKey*>(unresolvedKey);
  
         errorMessage << "Problem with section offset keys. "
                      << "Requested section identification code: "
                      << static_cast<int>(sectionOffsetKey->sectionId())
                      << " offset: "
                      << sectionOffsetKey->offset() << std::endl;
  
         firstUnresolvedPointerOfList =
             (*sectionOffsetMap_->find(*sectionOffsetKey)).second->front();
     }
  
     if (unresolvedReferences(*fileOffsetMap_,  &unresolvedKey)) {
         const FileOffsetKey *fileOffsetKey =
             dynamic_cast<const FileOffsetKey*>(unresolvedKey);
  
         errorMessage << "Problem with file offset keys. "
                      << "Requested section identification code: "
                      << fileOffsetKey->fileOffset() << std::endl;
  
         firstUnresolvedPointerOfList =
             (*fileOffsetMap_->find(*fileOffsetKey)).second->front();
     }
  
     if (errorMessage.str() != "") {
  
 #ifndef NDEBUG
         assert(firstUnresolvedPointerOfList != NULL);
         errorMessage << " SafePointer created in : "
                      << firstUnresolvedPointerOfList->debugString();
 #endif
         throw UnresolvedReference(
             __FILE__, __LINE__, __func__, errorMessage.str());
     }
 }

Referenced by TPEF::BinaryReader::readBinary().

Here is the call graph for this function:

◆ safelyCleanupKeyTable()

template<typename MapType >

static void TPEF::ReferenceManager::SafePointer::safelyCleanupKeyTable	(	MapType &	sourceMap,
		std::set< SafePointerList * > &	listsToDelete
	)

staticprotected

Referenced by cleanupKeyTables().

◆ sectionIndexKeyFor()

SectionIndexKey TPEF::ReferenceManager::SafePointer::sectionIndexKeyFor ( const SafePointable * obj )

static

Returns the SectionIndexKey connected to given object.

Returns: The key.

Parameters

obj	Object to look the key for.

Exceptions

KeyNotFound If the key cannot be found for the object.

Definition at line 366 of file SafePointer.cc.

                                                         {
     return genericKeyFor<SectionIndexKey>(obj, *sectionIndexMap_);
 }

References sectionIndexMap_.

Referenced by TPEF::SectionIndexReplacer::tryToReplace().

◆ sectionKeyFor()

SectionKey TPEF::ReferenceManager::SafePointer::sectionKeyFor ( const SafePointable * obj )

static

Returns the SectionKey connected to given object.

Returns: The key.

Parameters

obj	Object to look the key for.

Exceptions

KeyNotFound If the key cannot be found for the object.

Definition at line 408 of file SafePointer.cc.

                                                    {
     return genericKeyFor<SectionKey>(obj, *sectionMap_);
 }

References sectionMap_.

Referenced by TPEF::TPEFStringSectionWriter::actualWriteData(), TPEF::TPEFASpaceSectionWriter::actualWriteData(), TPEF::TPEFDataSectionWriter::actualWriteData(), TPEF::TPEFCodeSectionWriter::actualWriteData(), TPEF::TPEFSymbolSectionWriter::actualWriteData(), TPEF::TPEFUDataSectionWriter::createKeys(), TPEF::TPEFRelocSectionReader::finalize(), and TPEF::SectionIdReplacer::tryToReplace().

◆ sectionOffsetKeyFor()

SectionOffsetKey TPEF::ReferenceManager::SafePointer::sectionOffsetKeyFor ( const SafePointable * obj )

static

Returns the SectionOffsetKey connected to given object.

Returns: The key.

Parameters

obj	Object to look the key for.

Exceptions

KeyNotFound If the key cannot be found for the object.

Definition at line 380 of file SafePointer.cc.

                                                          {
     return genericKeyFor<SectionOffsetKey>(obj, *sectionOffsetMap_);
 }

References sectionOffsetMap_.

Referenced by TPEF::SectionOffsetReplacer::tryToReplace().

◆ setPointer()

void TPEF::ReferenceManager::SafePointer::setPointer ( SafePointable * object )

Referenced by TPEF::ReferenceManager::SafePointerList::append().

◆ unresolvedReferences()

template<typename MapType >

static bool TPEF::ReferenceManager::SafePointer::unresolvedReferences	(	const MapType &	mapToCheck,
		const ReferenceKey **	unresolvedKey
	)

static

Referenced by resolve().

Member Data Documentation

◆ aliveSafePointers_

SafePointerSet * TPEF::ReferenceManager::SafePointer::aliveSafePointers_ = new SafePointerSet

staticprivate

Set that cointains all alive (not deleted) SafePointers for extra safety.

Definition at line 332 of file SafePointer.hh.

Referenced by isAlive().

◆ debugString_

std::string TPEF::ReferenceManager::SafePointer::debugString_

private

Definition at line 352 of file SafePointer.hh.

◆ fileOffsetMap_

FileOffsetMap * TPEF::ReferenceManager::SafePointer::fileOffsetMap_ = new FileOffsetMap

staticprivate

Map of SafePointers that are requested using FileOffsetKeys.

Definition at line 322 of file SafePointer.hh.

Referenced by addObjectReference(), cleanupKeyTables(), fileOffsetKeyFor(), notifyDeleted(), resolve(), and SafePointer().

◆ keyForCache_

SafePointer::KeyForCacheMap * TPEF::ReferenceManager::SafePointer::keyForCache_

staticprivate

Initial value:

=

new SafePointer::KeyForCacheMap

Map for cache.

Definition at line 343 of file SafePointer.hh.

Referenced by cleanupKeyTables().

◆ null

const SafePointer TPEF::ReferenceManager::SafePointer::null

static

The default SafePointer that is used in null references.

Definition at line 229 of file SafePointer.hh.

Referenced by TPEF::ASpaceSection::isUndefined(), TPEF::TPEFSectionReader::readData(), TPEF::TPEFReader::readData(), and TPEF::TPEFLineNumSectionReader::readInfo().

◆ object_

SafePointable* TPEF::ReferenceManager::SafePointer::object_

private

The reference to the real object.

Definition at line 313 of file SafePointer.hh.

◆ referenceMap_

ReferenceMap * TPEF::ReferenceManager::SafePointer::referenceMap_ = new ReferenceMap

staticprivate

Map of SafePointers that have resolved references.

Definition at line 328 of file SafePointer.hh.

Referenced by cleanup(), isReferenced(), notifyDeleted(), resolve(), and SafePointer().

◆ sectionIndexMap_

SectionIndexMap * TPEF::ReferenceManager::SafePointer::sectionIndexMap_ = new SectionIndexMap

staticprivate

Map of SafePointers that are requested using SectionIndexKeys.

Definition at line 316 of file SafePointer.hh.

Referenced by addObjectReference(), cleanupKeyTables(), notifyDeleted(), resolve(), SafePointer(), and sectionIndexKeyFor().

◆ sectionMap_

SectionMap * TPEF::ReferenceManager::SafePointer::sectionMap_ = new SectionMap

staticprivate

Map of SafePointers that are requested using SectionKeys.

Definition at line 325 of file SafePointer.hh.

Referenced by addObjectReference(), cleanupKeyTables(), notifyDeleted(), resolve(), SafePointer(), and sectionKeyFor().

◆ sectionOffsetMap_

SectionOffsetMap * TPEF::ReferenceManager::SafePointer::sectionOffsetMap_ = new SectionOffsetMap

staticprivate

Map of SafePointers that are requested using SectionOffsetKeys.

Definition at line 319 of file SafePointer.hh.

Referenced by addObjectReference(), cleanupKeyTables(), notifyDeleted(), resolve(), SafePointer(), and sectionOffsetKeyFor().

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

Public Member Functions

Static Public Member Functions

Static Public Attributes

Protected Member Functions

Static Protected Member Functions

Private Types

Private Member Functions

Private Attributes

Static Private Attributes

Detailed Description

Member Typedef Documentation

◆ KeyForCacheKey

◆ KeyForCacheMap

Constructor & Destructor Documentation

◆ ~SafePointer()

◆ SafePointer() [1/6]

◆ SafePointer() [2/6]

◆ SafePointer() [3/6]

◆ SafePointer() [4/6]

◆ SafePointer() [5/6]

◆ SafePointer() [6/6]

Member Function Documentation

◆ addObjectReference() [1/4]

◆ addObjectReference() [2/4]

◆ addObjectReference() [3/4]

◆ addObjectReference() [4/4]

◆ cleanup()

◆ cleanupKeyTables()

◆ fileOffsetKeyFor()

◆ genericAddObjectReference()

◆ genericCreate()

◆ genericKeyFor()

◆ genericRegisterPointer()

◆ isAlive()

◆ isReferenced()

◆ notifyDeleted() [1/2]

◆ notifyDeleted() [2/2]

◆ operator=()

◆ pointer()

◆ replaceAllReferences()

◆ replaceReference()

◆ resolve()

◆ safelyCleanupKeyTable()

◆ sectionIndexKeyFor()

◆ sectionKeyFor()

◆ sectionOffsetKeyFor()

◆ setPointer()

◆ unresolvedReferences()

Member Data Documentation

◆ aliveSafePointers_

◆ debugString_

◆ fileOffsetMap_

◆ keyForCache_

◆ null

◆ object_

◆ referenceMap_

◆ sectionIndexMap_

◆ sectionMap_

◆ sectionOffsetMap_