CAcHierarchy Class Reference

#include <CAcHierarchy.h>

Inheritance diagram for CAcHierarchy:

List of all members.

Public Member Functions
	CAcHierarchy (const CXMLElement &inConfiguration)
CIDRelevanceLevelPairList *	getChildren (const CPath &inID) const
void	addElement (TID inID, string inLocation, string inThumbnail)
void	push (TID inNode)
void	popNodeAndRegisterEdge ()
	operator bool () const
Protected Types
typedef list< TID >	CPath
typedef list< TID >	CChildren
typedef map< CPath, CChildren >	CGraph
Protected Member Functions
void	init (string inFileName)
void	addEdge (const CPath &inFather, TID inSon)
Protected Attributes
CMutex	mMutexHierarchy
bool	isOK
CPath	mNodeStack
CGraph	mEdges

---

Detailed Description

A very simple accessor for hierarchies of images Stored in an XML file.

This was intended as the ultra simple example system for the browser benchmarking paper. It performed too bad in our benchmark to be taken seriously.

Currently I see the use of this as the base for systems, where the author knows how to generate a hierarchy of images, but the author fears the overhead needed for including his/her system into the gift.

Please note that IDs must start at 1 (ONE!!!).

Author:

Wolfgang Müller

Definition at line 52 of file CAcHierarchy.h.

---

Member Typedef Documentation

typedef list<TID> CAcHierarchy::CPath [protected]

In fact, because images can arise multiple times in the hierarchy, it is necessary to store the full path for each time the image arises in the tree.

We base this on the idea that in each selection, each image will arise at most once. As a consequence, lists of selected images must be sufficient to define the path from the hierarchy's root to a given node or leaf of the hierarchy.

Definition at line 69 of file CAcHierarchy.h.

typedef list<TID> CAcHierarchy::CChildren [protected]

This class is there for mnemonic reasons only. Evidently it has the same type as CPath, however it designates a list of children.

Definition at line 74 of file CAcHierarchy.h.

typedef map<CPath,CChildren> CAcHierarchy::CGraph [protected]

The graph is represented as a map from path to children.

See also:

CPath for an explanation

Definition at line 83 of file CAcHierarchy.h.

---

Constructor & Destructor Documentation

CAcHierarchy::CAcHierarchy

(

const CXMLElement &

inConfiguration

)

constructor opens a hierarchy file and reads it.

Like every accessor, this accessor takes a <collection> MRML element as input (

See also:

CXMLElement for how to access the attributes of this element). Currently this accessor understands the following attributes:

cui-base-dir: the base directory containing the following file: cui-hierarchy-file-location: an xml file containing the hierarchy that you can browse using this accessor.

Definition at line 111 of file CAcHierarchy.cc.

References mrml_const::cui_base_dir, mrml_const::cui_hierarchy_file_location, init(), CMutex::lock(), mMutexHierarchy, and CMutex::unlock().

                                                                {
  mMutexHierarchy.lock();
  init(inCollectionElement
       .stringReadAttribute(mrml_const::cui_base_dir).second
       +inCollectionElement
       .stringReadAttribute(mrml_const::cui_hierarchy_file_location).second);
  mMutexHierarchy.unlock();
}

---

Member Function Documentation

void CAcHierarchy::init

(

string

inFileName

)

[protected]

called immediately by the constructor, this function does the main construction work. Starts the xml parser for reading the hierarchy file etc.

Definition at line 120 of file CAcHierarchy.cc.

References endHierarchyElement(), CMutex::lock(), mMutexHierarchy, my_throw, startHierarchyElement(), and CMutex::unlock().

Referenced by CAcHierarchy().

                                        {
  mMutexHierarchy.lock();

  ifstream lHierarchyFile(inFileName.c_str());
  if(lHierarchyFile){
      lHierarchyFile.seekg(0,ios::end);
      int lSize=lHierarchyFile.tellg();
      char lHierarchyFileContent[lSize+1];
      
      lHierarchyFile.seekg(0,ios::beg);
      lHierarchyFile.read(lHierarchyFileContent,
        lSize);
      
      lHierarchyFileContent[lSize]=0;
      
      cout << "I did it: I read the HIERARCHY file "
     << inFileName
     << ": "
     << lHierarchyFileContent
     << endl
     << flush;

      XML_Parser lParser = XML_ParserCreate(NULL);//default encoding
      XML_SetUserData(lParser,
          this);
      XML_SetElementHandler(lParser, 
          startHierarchyElement, 
          endHierarchyElement);
      int lDone=true;

      do {
  if (!XML_Parse(lParser, 
           lHierarchyFileContent, 
           lSize, 
           lDone)) {
    cerr << "XML ERROR: "
         << XML_ErrorString(XML_GetErrorCode(lParser))
         << " at line "
         << XML_GetCurrentLineNumber(lParser)
         << endl;
    my_throw(VEConfigurationError("could not find requested tree"));
  }
      } while (!lDone);

      XML_ParserFree(lParser);  
      mMutexHierarchy.unlock();
  }else{
    mMutexHierarchy.unlock();
    my_throw(string(string("could not open config file_")+inFileName+string("_")).c_str());
  }
};

void CAcHierarchy::addEdge	(	const CPath &	inFather,
		TID	inSon
	)			[protected]

adds an edge from father to son and an edge from son to father

Definition at line 214 of file CAcHierarchy.cc.

References CMutex::lock(), mEdges, mMutexHierarchy, and CMutex::unlock().

Referenced by popNodeAndRegisterEdge().

                   {
  mMutexHierarchy.lock();

  mEdges[inPath].push_back(inSon);
  cout << "SIZE addBackForthEdge: ("
       << inSon
       << ") "
       << mEdges[inPath].size()
       << " "
       << inPath.size()
       << " "
       << mEdges.size()
       << endl;
  mMutexHierarchy.unlock();
}

CIDRelevanceLevelPairList * CAcHierarchy::getChildren

(

const CPath &

inID

)

const

Gets a list of all children of an element. As it was said before, an element of the hierarchy is well described by a path in the tree, from the root to this element.

Definition at line 231 of file CAcHierarchy.cc.

References CMutex::lock(), mEdges, mMutexHierarchy, and CMutex::unlock().

                                                                            {
  mMutexHierarchy.lock();

  CGraph::const_iterator lFound(mEdges.find(inPath));
  
  if(lFound!=mEdges.end()){
    CIDRelevanceLevelPairList* lList(new CIDRelevanceLevelPairList());
    
    for(list<TID>::const_iterator i=lFound->second.begin();
  i!=lFound->second.end();
  i++){
      lList->push_back(CIDRelevanceLevelPair(*i,1.0));
    }
    return lList;
  }

  cout << "NOTFOUND" << endl;

  mMutexHierarchy.unlock();
  return 0;
}

void CAcHierarchy::addElement	(	TID	inID,
		string	inLocation,
		string	inThumbnail
	)

Adds an element to the collection

Definition at line 172 of file CAcHierarchy.cc.

References CMutex::lock(), CAccessorImplementation::mIDToAccessorElement, mMutexHierarchy, CAccessorImplementation::mURLToID, and CMutex::unlock().

Referenced by startHierarchyElement().

                               {
  mMutexHierarchy.lock();

  mIDToAccessorElement.insert(make_pair(inID,
          CAccessorElement(inID,
               inLocation,
               inThumbnail,
               string(""))));
  
  mURLToID[inLocation]=inID;
  mMutexHierarchy.unlock();
}

void CAcHierarchy::push

(

TID

inNode

)

pushes the node onto the stack

pushes the node onto the stack

Definition at line 191 of file CAcHierarchy.cc.

References CMutex::lock(), mMutexHierarchy, mNodeStack, and CMutex::unlock().

Referenced by startHierarchyElement().

                                 {
  mMutexHierarchy.lock();
  mNodeStack.push_back(inNode);
  mMutexHierarchy.unlock();
};

void CAcHierarchy::popNodeAndRegisterEdge

(

)

pops the node and registers the edge from new top to old top and back

pops the node and registers the edge from new top to old top and back

Definition at line 202 of file CAcHierarchy.cc.

References addEdge(), CMutex::lock(), mMutexHierarchy, mNodeStack, and CMutex::unlock().

Referenced by endHierarchyElement().

                                         {
  mMutexHierarchy.lock();

  if(mNodeStack.size()){
    TID lExTop=mNodeStack.back();
    
    mNodeStack.pop_back();
    
    addEdge(mNodeStack,lExTop);
  }
  mMutexHierarchy.unlock();
};

CAcHierarchy::operator bool

(

)

const [virtual]

has this been successfully read?

Implements CAccessorImplementation.

Definition at line 253 of file CAcHierarchy.cc.

                                {
  return true;
}

---

Member Data Documentation

CMutex CAcHierarchy::mMutexHierarchy [protected]

mutual exclude for multithreading

Definition at line 55 of file CAcHierarchy.h.

Referenced by addEdge(), addElement(), CAcHierarchy(), getChildren(), init(), popNodeAndRegisterEdge(), and push().

bool CAcHierarchy::isOK [protected]

is this well constructed ?

Definition at line 57 of file CAcHierarchy.h.

CPath CAcHierarchy::mNodeStack [protected]

A stack of the nodes visited when building the hierarchy

Definition at line 78 of file CAcHierarchy.h.

Referenced by popNodeAndRegisterEdge(), and push().

CGraph CAcHierarchy::mEdges [protected]

Edges: The edges from father to son. The edges from son to father are not needed, because it means simply popping from the path.

Definition at line 89 of file CAcHierarchy.h.

Referenced by addEdge(), and getChildren().

---

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

• gift/libGIFTAcHierarchy/include/CAcHierarchy.h
• gift/libGIFTAcHierarchy/cc/CAcHierarchy.cc