freIDPath.h

Go to the documentation of this file.

/*=========================================================================

  Program:   F.R.E.E. - flexible registration evaluation engine
  Version:   v.1.0.0
  Date:      $Date: 2006/09/01 12:00:00 $
  Module:    $RCSfile: freIDPath.h,v $
  Language:  C++


  Copyright (c) 2007 Ralf o Floca (Department of Medical Informatics,
  Institute for Medical Biometry and Informatics, University of Heidelberg,
  Germany). All rights reserved.
  See FREECopyright.txt or http://www.mi.med.uni-hd.de/free/copyright.htm
  for details.

     This software is distributed WITHOUT ANY WARRANTY; without even 
     the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR 
     PURPOSE.  See the above copyright notices for more information.

=========================================================================*/
#ifndef __freIDPath_h
#define __freIDPath_h

#include "freElementals.h"
#include "freXMLStreamObject.h"
#include "freComponentID.h"

namespace FREE
{

class IDPath : public XMLStreamObject
{
public:  
  enum PathElementType
  {
    PTNULL = 0,          //*< Element is non existant or invalid.
    PTSelf = 1,          //*< Selects itself as actual node (".").
    PTParent = 2,        //*< Selects parent as actual node ("..").
    PTAnyChild = 3,      //*< Selects any component that is a child of the actual node ("*").
    PTAnyDescendant = 4, //*< Selects any descendant compnent of the actual node ("//").
    PTComponent = 5,     //*< Selects components with the specified ID (any legal component id).
    PTParameter = 6,      //*< Selects an attribute/parameter of the actual component (any parameter name with a @ as prefix).
    PTMedia = 7          //*< Selects a media component of the actual component (any parameter name with a # as prefix).
  };

  bool IsEmpty() const {return m_ElementTypes.size()==0;};
  bool IsAbsolute() const { return m_bAbsolute; };
  bool IsRoot() const { return IsAbsolute() && IsEmpty(); };

  void SetAbsolute(const bool& bAbsolute) { this->m_bAbsolute = bAbsolute; };

  bool IsParameterSelection() const;

  bool IsMediaSelection() const;

  bool IsComponentSelection() const;

  inline unsigned int Size() const;

  unsigned int AddComponent(const PathElementType& elementType, const std::string& sTag);

  PathElementType GetComponent(const unsigned int& index, std::string& sTag) const;

  PathElementType GetFirstComponent(std::string& sTag) const;

  IDPath GetSubIDPath() const;

  IDPath GetParentIDPath() const;

  IDPath GetParentComponentIDPath() const;

  IDPath GetParameterIDPath() const;

  std::string GetParameterName() const;

  std::string GetMediaID() const;

  std::string GetComponentID() const;

  IDPath TransformIDPath(const IDPath& origin) const;

  inline operator std::string() const {return this->ToStr();};

  std::string ToStr() const;

  bool operator == (const IDPath& path) const;

  bool Equals(const IDPath& path) const;

  bool ChildOf(const IDPath& path) const;

        IDPath& operator = (const IDPath& path);
  IDPath& operator = (const std::string& path);
  IDPath& operator = (const char* path);

  IDPath operator + (const IDPath& modPath) const;

  static IDPath Concat(const IDPath& path1, const IDPath& path2);

  IDPath();
  IDPath(const IDPath& path);
  IDPath(const std::string& path);
  IDPath(const char* path);

  ~IDPath();

  virtual void Reset();

  static IDPath Parameter(const std::string& sParameterName, unsigned long lValueID = 0, unsigned long lLayerID = 0);
  static IDPath Media(const std::string& sMediaName);

protected:
  virtual void SubElementLoadProcessing(const std::string& rsXMLSubTag, const std::string& rsXMLSubElement, const std::string& rsXMLSubData);
  virtual std::string SaveData(const unsigned int& iDepth, bool& bHasSubElements) const;

  IDPath AssembleIDPath(const unsigned int& iFirstID, const unsigned int& iLastID) const;

  static bool IDPathesMatch(const IDPath& left, const IDPath& right);

  enum TokenType
  {
    TTSlash = 0,    // : /
    TTDot = 1,      // : .
    TTDDot = 2,     // : ..
    TTWildcard = 3, // : *
    TTDSlash = 4,   // : //
    TTComponent = 5 // : anything else
  };

  static bool GetFirstToken(const std::string& sIDPath, TokenType& token, std::string& sFirstTag, std::string& sSubPath );

  static PathElementType GetComponentType(const std::string& sTokenTag, std::string& sComponentID);

  typedef std::vector<PathElementType> PathElementTypeVector;

  PathElementTypeVector m_ElementTypes;
  STLStringVector m_ElementTags;

  bool m_bAbsolute;
};

static bool operator == (const std::string& left, const IDPath& right)
{
  return IDPath(left) == right;
};

static bool operator == (const IDPath& left, const std::string& right)
{
  return  left == IDPath(right);
};

void DispatchParameterIDPath(const IDPath& parameterID, std::string& sParameterName, unsigned long& riItemPos, unsigned long& riLayer);

//default ID pathes
static const IDPath cIDPSelf(".");
static const IDPath cIDPParent("..");
static const IDPath cIDPRoot("/");
static const IDPath cIDPEveryone("//*");

static const IDPath cIDPMediaMoving(std::string("/")+cComp_MediaMoving);
static const IDPath cIDPMediaFixed(std::string("/")+cComp_MediaFixed);
static const IDPath cIDPMediaFinal(std::string("/")+cComp_MediaFinal);
static const IDPath cIDPMediaInterim(std::string("/")+cComp_MediaInterim);

typedef std::vector<IDPath> IDPathVectorType;
} //end of namespace FREE

#endif

---