freIDPath.cxx

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.cxx,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.

=========================================================================*/
#include "freIDPath.h"
#include "freExceptions.h"
#include "freConvert.h"

namespace FREE
{

bool
IDPath::
IsParameterSelection() const
{
  PathElementTypeVector::const_iterator pos;

  for (pos = m_ElementTypes.begin(); pos!=m_ElementTypes.end(); pos++)
  {
    if (*pos == IDPath::PTParameter) return true;
  }

  return false;
};

bool
IDPath::
IsMediaSelection() const
{
  PathElementTypeVector::const_iterator pos;

  for (pos = m_ElementTypes.begin(); pos!=m_ElementTypes.end(); pos++)
  {
    if (*pos == IDPath::PTMedia) return true;
  }

  return false;
};

bool
IDPath::
IsComponentSelection() const
{
  return !(IsMediaSelection() || IsParameterSelection());
};

unsigned int
IDPath::
Size() const
{
  return m_ElementTypes.size();
};

unsigned int
IDPath::
AddComponent(const PathElementType& elementType, const std::string& sTag)
{
  m_ElementTypes.push_back(elementType);
  m_ElementTags.push_back(sTag);
  return m_ElementTypes.size()-1;
};

IDPath::PathElementType
IDPath::
GetComponent(const unsigned int& index, std::string& sTag) const
{
  if ((index<0) || (index>=Size()))
  {
    sTag = "";
    return IDPath::PTNULL;
  }

  sTag = m_ElementTags[index];
  return m_ElementTypes[index];
};


IDPath::PathElementType
IDPath::
GetFirstComponent(std::string& sTag) const
{
  return GetComponent(0,sTag);
};


IDPath
IDPath::
GetSubIDPath() const
{
  IDPath newPath = AssembleIDPath(1,Size()-1);
  return newPath;
};

IDPath
IDPath::
GetParentIDPath() const
{
  IDPath newPath = AssembleIDPath(0,Size()-2);
  newPath.SetAbsolute(this->IsAbsolute());
  return newPath;
};

IDPath
IDPath::
GetParentComponentIDPath() const
{
        IDPath newPath = GetParentIDPath();
        while (!newPath.IsEmpty())
        {
                if (newPath.IsComponentSelection()) break;
                newPath = newPath.GetParentIDPath();
        }
        return newPath;
};


IDPath
IDPath::
GetParameterIDPath() const
{
  IDPath newPath;

  PathElementTypeVector::const_iterator pos;
  int iParaPos = 0;

  for (pos = m_ElementTypes.begin(); pos!=m_ElementTypes.end(); pos++, iParaPos++)
  {
    if (*pos == IDPath::PTParameter) break;
  }

  if (iParaPos<Size())
  {
    newPath = AssembleIDPath(iParaPos,Size()-1);
  }
  
  return newPath;
};

std::string
IDPath::
GetParameterName() const
{
  PathElementTypeVector::const_iterator pos;
  STLStringVector::const_iterator posTag = m_ElementTags.begin();

  for (pos = m_ElementTypes.begin(); pos!=m_ElementTypes.end(); pos++, posTag++)
  {
    if (*pos == IDPath::PTParameter) return *posTag;
  }
  return "";
};

std::string
IDPath::
GetMediaID() const
{
  PathElementTypeVector::const_iterator pos;
  STLStringVector::const_iterator posTag = m_ElementTags.begin();

  for (pos = m_ElementTypes.begin(); pos!=m_ElementTypes.end(); pos++, posTag++)
  {
                if (*pos == IDPath::PTMedia) return *posTag;
  }
  return "";
};

std::string
IDPath::
GetComponentID() const
{
  PathElementTypeVector::const_reverse_iterator pos;
  STLStringVector::const_reverse_iterator posTag = m_ElementTags.rbegin();

  for (pos = m_ElementTypes.rbegin(); pos!=m_ElementTypes.rend(); pos++, posTag++)
  {
    if (*pos == IDPath::PTComponent) return *posTag;
  }
  return "";
};

std::string
IDPath::
ToStr() const
{
  std::string sPath;

  if (Size() == 0) return sPath;

  if (this->m_ElementTypes[0] != IDPath::PTAnyDescendant)
  {
    if (this->IsAbsolute()) sPath = "/";
  }

  for (unsigned int i = 0; i<m_ElementTypes.size(); i++)
  {
    if (this->m_ElementTypes[i] == IDPath::PTAnyChild) sPath += "*";
    else if (this->m_ElementTypes[i] == IDPath::PTAnyDescendant) sPath += "//";
    else if (this->m_ElementTypes[i] == IDPath::PTComponent) sPath += this->m_ElementTags[i];
    else if (this->m_ElementTypes[i] == IDPath::PTParameter) sPath += "@"+this->m_ElementTags[i];
                else if (this->m_ElementTypes[i] == IDPath::PTMedia) sPath += "#"+this->m_ElementTags[i];
    else if (this->m_ElementTypes[i] == IDPath::PTParent) sPath += "..";
                else if (this->m_ElementTypes[i] == IDPath::PTSelf) sPath += ".";

    if ((i < m_ElementTypes.size()-1) && (this->m_ElementTypes[0] != IDPath::PTAnyDescendant))
    { //if it isn't the last element and it is not "//" a "/" is needed as seperator
      sPath += "/";
    }
  }

  return sPath;
};

bool
IDPath::
operator == (const IDPath& path) const
{
  return IDPathesMatch(*this,path);
};

bool
IDPath::
Equals(const IDPath& path) const
{
        return this->ToStr() == path.ToStr();
};

bool
IDPath::
ChildOf(const IDPath& path) const
{
        std::string sTag;
        PathElementType pe = GetComponent(this->Size()-1,sTag);
        if (pe == IDPath::PTNULL) return false;
        if (pe == IDPath::PTAnyChild) sTag = "*";
        if (pe == IDPath::PTMedia) sTag = "#"+sTag;
        if (pe == IDPath::PTParameter) sTag = "@"+sTag;

        sTag = ".//"+sTag;

        IDPath childPath = path + sTag;

        return this->operator ==(childPath);
};

IDPath&
IDPath::
operator = (const IDPath& path)
{
  if (&path == this) return *this;

  Reset();

  this->m_bAbsolute = path.IsAbsolute();

  for (unsigned int i = 0; i<path.Size(); i++)
  {
    std::string sTag;
    PathElementType token = path.GetComponent(i,sTag);
    this->AddComponent(token,sTag);
  }

  return *this;
};

IDPath&
IDPath::
operator = (const std::string& path)
{
  TokenType token;
  std::string sSubPath;
  std::string sTag;

  Reset();

  bool bProceed = this->GetFirstToken(path,token,sTag,sSubPath);
  this->SetAbsolute(token == IDPath::TTSlash);

  while (bProceed)
  {
    if (token != IDPath::TTSlash)
    {
      if (token == IDPath::TTComponent)
      { //component, parameter or media?
        std::string sComponentID = "";
        PathElementType pe = GetComponentType(sTag,sComponentID);
        this->AddComponent(pe, sComponentID);
      }
      else
      { 
        this->AddComponent((IDPath::PathElementType)token,"");
        //all other tokens have the same ID like their corresponding path element types
        //and they have no tags.
      }
    }
    bProceed = this->GetFirstToken(sSubPath,token,sTag,sSubPath);
  }

  return *this;
};

IDPath&
IDPath::
operator = (const char* path)
{
  std::string sTemp = path;
  *this = sTemp;
  return *this;
};

IDPath
IDPath::
TransformIDPath(const IDPath& origin) const
{
  return origin + (*this);
};

IDPath
IDPath::
operator + (const IDPath& modPath) const
{
  if (modPath.IsAbsolute()) return modPath;

  IDPath newPath = *this;
  IDPath newModPath = modPath;

  std::string sTag;
  PathElementType token = newModPath.GetFirstComponent(sTag);

  while ((token == IDPath::PTParent) || (token == IDPath::PTSelf))
  {
    newModPath = newModPath.GetSubIDPath();

    if (token == IDPath::PTParent) newPath = newPath.GetParentIDPath();

    token = newModPath.GetFirstComponent(sTag);
  }

  return Concat(newPath, newModPath);
};

IDPath
IDPath::Concat(const IDPath& path1, const IDPath& path2)
{
  IDPath newPath = path1;
  for (unsigned int i = 0; i<path2.Size(); i++)
  {
    std::string sTag;
    PathElementType token = path2.GetComponent(i,sTag);
    newPath.AddComponent(token,sTag);
  }

  return newPath;
};

IDPath::IDPath():XMLStreamObject(cXML_IDPath)
{
  Reset();
};

IDPath::
IDPath(const IDPath& path):XMLStreamObject(cXML_IDPath)
{
  *this = path;
};

IDPath::
IDPath(const std::string& path):XMLStreamObject(cXML_IDPath)
{
  *this = path;
};

IDPath::
IDPath(const char* path):XMLStreamObject(cXML_IDPath)
{
  *this = path;
};

IDPath::
~IDPath() {};

void
IDPath::
Reset()
{
  this->m_bAbsolute = true;
  this->m_ElementTags.clear();
  this->m_ElementTypes.clear();
};

void
IDPath::
SubElementLoadProcessing(const std::string& rsXMLSubTag, const std::string& rsXMLSubElement, const std::string& rsXMLSubData)
{
  *this = rsXMLSubData;
};

std::string
IDPath::
SaveData(const unsigned int& iDepth, bool& bHasSubElements) const
{
  bHasSubElements = false;
  return this->ToStr();
};

IDPath
IDPath::
AssembleIDPath(const unsigned int& iFirstID, const unsigned int& iLastID) const
{
  IDPath newPath;
  newPath.SetAbsolute(false);

  if ((iFirstID<0)||(iFirstID>=this->Size())) return newPath;

  unsigned int iActLastID = iLastID;

  if (iLastID>=Size()) iActLastID = Size()-1;

  for (unsigned int i = iFirstID; i<=iActLastID; i++)
  {
    std::string sTag;
    PathElementType token = this->GetComponent(i,sTag);
    newPath.AddComponent(token,sTag);
  }

  return newPath;
};

bool
IDPath::
IDPathesMatch(const IDPath& left, const IDPath& right)
{
  if ((left.IsEmpty())&&(right.IsEmpty())) return true;
  else if (left.IsEmpty()||right.IsEmpty()) return false;
//  if (left.IsAbsolute() != right.IsAbsolute()) return false;

  std::string sLeftComp;
  std::string sRightComp;

  PathElementType leftToken = left.GetFirstComponent(sLeftComp);
  PathElementType rightToken = right.GetFirstComponent(sRightComp);

  if ((leftToken == IDPath::PTAnyDescendant) || (rightToken == IDPath::PTAnyDescendant))
  {
    IDPath search = right;
    IDPath pattern = left.GetSubIDPath();
    
                if (rightToken == IDPath::PTAnyDescendant) 
    {
      search = left;
      pattern = right.GetSubIDPath();
                };

    while (!search.IsEmpty())
          {
                        if (IDPathesMatch(search,pattern)) return true;
                        search = search.GetSubIDPath();
                };

    return false;
    //if one token is double slashed and no match is found yet there will be no match anyway
    //it also handels the fact when both pathes are double slashed as a nested recursion.
  }

  if (((leftToken == IDPath::PTAnyChild) || (rightToken == IDPath::PTAnyChild)) ||
      ((sLeftComp==sRightComp) && (rightToken==leftToken)))
  { //untill now everythin is legal, proceed to next part of the pathes.
    return IDPathesMatch(left.GetSubIDPath(),right.GetSubIDPath());
  }
  
  return false;
};

bool
IDPath::
GetFirstToken(const std::string& sIDPath, TokenType& token, std::string& sFirstTag, std::string& sSubPath )
{
  std::string sPath = sIDPath;

  unsigned int pos = sPath.find_first_of("/");
        if ((pos==0) && (sPath.size()>1))
        {
                if (sPath[1]=='/') pos = 1;
        }

  unsigned int subPos = pos+1;
  if ((subPos >= sPath.size())||(pos==std::string::npos)) sSubPath = "";
  else sSubPath = sPath.substr(subPos);

  sFirstTag = sPath.substr(0,pos);
 
  if (sFirstTag =="") token = TTSlash;
  else if (sFirstTag =="/") token = TTDSlash;
  else if (sFirstTag ==".") token = TTDot;
  else if (sFirstTag =="..") token = TTDDot;
  else if (sFirstTag =="*") token = TTWildcard;
  else token = TTComponent;

  if (sPath.empty()) return false;
  return true;
};

IDPath::PathElementType
IDPath::
GetComponentType(const std::string& sTokenTag, std::string& sComponentID)
{
  unsigned int pos = sTokenTag.find_first_of("@");
        if (pos==0)
  { //it's an attibute / parameter
    if (sTokenTag.size()<2) throwStaticExceptionMacro("Error, while converting string to IDPath. Parameter specified, but parameter name missing.");
    sComponentID = sTokenTag.substr(1);
    return IDPath::PTParameter;
  }

  pos = sTokenTag.find_first_of("#");
        if (pos==0)
  { //it's a media component
    if (sTokenTag.size()<2) throwStaticExceptionMacro("Error, while converting string to IDPath. Media specified, but media name missing.");
    sComponentID = sTokenTag.substr(1);
    return IDPath::PTMedia;
  }

  pos = sTokenTag.find_first_of("::");
        if (pos!=-1)
  { //it has an axis definition.
    if (sTokenTag.substr(0,pos) == "attribute")
    {
      if (sTokenTag.size()<pos+3) throwStaticExceptionMacro("Error, while converting string to IDPath. Parameter specified, but parameter name missing.");
      sComponentID = sTokenTag.substr(pos+2);
      return IDPath::PTParameter;
    }

    if (sTokenTag.substr(0,pos) == "media")
    {
      if (sTokenTag.size()<pos+3) throwStaticExceptionMacro("Error, while converting string to IDPath. Media specified, but media name missing.");
      sComponentID = sTokenTag.substr(pos+2);
      return IDPath::PTMedia;
    }
  }

  sComponentID = sTokenTag;
  return IDPath::PTComponent;
};

IDPath
IDPath::
Parameter(const std::string& sParameterName, unsigned long lValueID, unsigned long lLayerID)
{
  IDPath result;
  result.SetAbsolute(false);
  result.AddComponent(IDPath::PTParameter,sParameterName);

  if (lValueID || lLayerID)
  { //if a layer or value ID is not default (so not 0), add the layer to the IDPath
    result.AddComponent(IDPath::PTComponent,Convert::ToStr(lLayerID));
  }

  if (lValueID)
  { //if a value ID is not default (so not 0) , add the value ID to the IDPath
    result.AddComponent(IDPath::PTComponent,Convert::ToStr(lValueID));
  }

  return result;
};

IDPath
IDPath::
Media(const std::string& sMediaName)
{
  IDPath result;
  result.SetAbsolute(false);
  result.AddComponent(IDPath::PTMedia,sMediaName);
  return result;
};

void DispatchParameterIDPath(const IDPath& parameterID, std::string& sParameterName, unsigned long& riItemPos, unsigned long& riLayer)
{
  riItemPos = 0;
  riLayer = 0;
  sParameterName = "";
  std::string sTemp;

  //ensure that the first component is the parameter
  IDPath parameterOnlyID = parameterID.GetParameterIDPath();

  if (parameterOnlyID.IsEmpty()) throwStaticExceptionMacro("IDPath is no parameter selection, hence not suitable for this function. Passed path: "<<parameterID.ToStr());

  parameterOnlyID.GetComponent(0,sParameterName);

  if (parameterOnlyID.GetComponent(1,sTemp) == IDPath::PTComponent)
  { //this should be a layer specificion
    if (!Convert::IsAInt(sTemp)) throwStaticExceptionMacro("IDPath seems to be invalid. Component tag after attribut element must be an integer specifying the layer. Found tag: "<<sTemp);
    riLayer = Convert::ToInt(sTemp);
  }

  if (parameterOnlyID.GetComponent(2,sTemp) == IDPath::PTComponent)
  { //this should be a layer specificion
    if (!Convert::IsAInt(sTemp)) throwStaticExceptionMacro("IDPath seems to be invalid. 2nd component tag after attribut element must be an integer specifying the value position. Found tag: "<<sTemp);
    riItemPos = Convert::ToInt(sTemp);
  }
};

} //end of namespace FREE

---