freParameterCollection.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: freParameter.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 "freParameterCollection.h"

#include "freConvert.h"

namespace FREE
{



Parameter*
ParameterCollection::
AddParameter(const std::string& sParameterName, const ValueCountType iLayerSize, const LayerCountType iLayerCount)
{
  Parameter::Pointer smpNewParameter = Parameter::New(sParameterName,iLayerSize,iLayerCount);
  m_Parameters.push_back(smpNewParameter);
  return smpNewParameter;
};

void
ParameterCollection::
DeleteParameter(const std::string& sParameterName)
{
  ParameterCountType index = GetParameterIndex(sParameterName);
  if (index!=-1)
  {
    DeleteParameter(index);
  };
};

void
ParameterCollection::
DeleteParameter(const ParameterCountType index)
{
  if (index<m_Parameters.size())
  {
    m_Parameters.erase(m_Parameters.begin()+index);
  };
};

void
ParameterCollection::
AddParameterLayer(const std::string& sParameterName, bool bCopyValue)
{
  ParameterCountType index = GetParameterIndex(sParameterName);
  if (index!=-1)
  {
    m_Parameters[index]->AddParameterLayer(bCopyValue);
  };
};

void
ParameterCollection::
DeleteParameterLayer(const std::string& sParameterName, const LayerCountType iLayer)
{
  ParameterCountType index = GetParameterIndex(sParameterName);
  if (index!=-1)
  {
    m_Parameters[index]->DeleteParameterLayer(iLayer);
  };
};

void
ParameterCollection::
ResetParameters()
{
  while (m_Parameters.size()>0)
  {
    DeleteParameter(0);
  };
};


void
ParameterCollection::
Reset()
{
  XMLStreamObject::Reset();
  ResetParameters();
};

bool
ParameterCollection::
ParameterExists(const std::string& sParameterName) const
{
  return GetParameterIndex(sParameterName)!=-1;
};

ParameterCollection::ParameterCountType
ParameterCollection::
Size() const
{
  return m_Parameters.size();
};

ParameterCollection::ValueCountType
ParameterCollection::
ParameterSize(const std::string& sParameterName) const
{
  ParameterCountType index = GetParameterIndex(sParameterName);
  if (index==-1) return 0;

  return m_Parameters[index]->ParameterSize();  
};

ParameterCollection::LayerCountType
ParameterCollection::
ParameterLayerCount(const std::string& sParameterName) const
{
  ParameterCountType index = GetParameterIndex(sParameterName);
  if (index==-1) return 0;

  return m_Parameters[index]->LayerCount();  
};

ParameterCollection::ParameterCountType
ParameterCollection::
GetParameterIndex(const std::string& sParameterName) const
{
  ParameterCountType index = 0; 
  for (ParametersType::const_iterator pos = m_Parameters.begin(); pos!=m_Parameters.end(); pos++)
  {
    if ((*pos)->GetParameterName()==sParameterName) return index;
    index++;
  };
  return -1;
};

std::string
ParameterCollection::
GetParameterName(const ParameterCountType& index) const
{
  if (index<m_Parameters.size()) return m_Parameters[index]->GetParameterName();

  return "";
};

bool
ParameterCollection::
GetParameterValue(const std::string& sParameterName, bool& value, const  ValueCountType iItemPos, const LayerCountType iLayer) const
{  
  ParameterCountType index = GetParameterIndex(sParameterName);
  if (index==-1) return false;
  return m_Parameters[index]->GetParameterValue(value,iItemPos,iLayer);
};

bool
ParameterCollection::
GetParameterValue(const std::string& sParameterName, double& value, const  ValueCountType iItemPos, const LayerCountType iLayer) const
{  
  ParameterCountType index = GetParameterIndex(sParameterName);
  if (index==-1) return false;
  return m_Parameters[index]->GetParameterValue(value,iItemPos,iLayer);
};
  
bool
ParameterCollection::
GetParameterValue(const std::string& sParameterName, int& value, const  ValueCountType iItemPos, const LayerCountType iLayer) const
{  
  ParameterCountType index = GetParameterIndex(sParameterName);
  if (index==-1) return false;
  return m_Parameters[index]->GetParameterValue(value,iItemPos,iLayer);
};

bool
ParameterCollection::
GetParameterValue(const std::string& sParameterName, long& value, const  ValueCountType iItemPos, const LayerCountType iLayer) const
{  
  ParameterCountType index = GetParameterIndex(sParameterName);
  if (index==-1) return false;
  return m_Parameters[index]->GetParameterValue(value,iItemPos,iLayer);
};

bool
ParameterCollection::
GetParameterValue(const std::string& sParameterName, unsigned long& value, const  ValueCountType iItemPos, const LayerCountType iLayer) const
{  
  ParameterCountType index = GetParameterIndex(sParameterName);
  if (index==-1) return false;
  return m_Parameters[index]->GetParameterValue(value,iItemPos,iLayer);
};

bool
ParameterCollection::
GetParameterValue(const std::string& sParameterName, std::string& value, const  ValueCountType iItemPos, const LayerCountType iLayer) const
{  
  ParameterCountType index = GetParameterIndex(sParameterName);
  if (index==-1) return false;
  return m_Parameters[index]->GetParameterValue(value,iItemPos,iLayer);
};

bool
ParameterCollection::
GetParameterValueByIDPath(const IDPath& parameterID, bool& value) const
{  
  std::string sParameterName;
  ValueCountType iItemPos = 0;
  LayerCountType iLayer = 0;

  DispatchParameterIDPath(parameterID,sParameterName,iItemPos,iLayer);
  return GetParameterValue(sParameterName,value,iItemPos,iLayer);
};

bool
ParameterCollection::
GetParameterValueByIDPath(const IDPath& parameterID, double& value) const
{  
  std::string sParameterName;
  ValueCountType iItemPos = 0;
  LayerCountType iLayer = 0;

  DispatchParameterIDPath(parameterID,sParameterName,iItemPos,iLayer);
  return GetParameterValue(sParameterName,value,iItemPos,iLayer);
};
  
bool
ParameterCollection::
GetParameterValueByIDPath(const IDPath& parameterID, int& value) const
{  
  std::string sParameterName;
  ValueCountType iItemPos = 0;
  LayerCountType iLayer = 0;

  DispatchParameterIDPath(parameterID,sParameterName,iItemPos,iLayer);
  return GetParameterValue(sParameterName,value,iItemPos,iLayer);
};

bool
ParameterCollection::
GetParameterValueByIDPath(const IDPath& parameterID, long& value) const
{  
  std::string sParameterName;
  ValueCountType iItemPos = 0;
  LayerCountType iLayer = 0;

  DispatchParameterIDPath(parameterID,sParameterName,iItemPos,iLayer);
  return GetParameterValue(sParameterName,value,iItemPos,iLayer);
};

bool
ParameterCollection::
GetParameterValueByIDPath(const IDPath& parameterID, unsigned long& value) const
{  
  std::string sParameterName;
  ValueCountType iItemPos = 0;
  LayerCountType iLayer = 0;

  DispatchParameterIDPath(parameterID,sParameterName,iItemPos,iLayer);
  return GetParameterValue(sParameterName,value,iItemPos,iLayer);
};

bool
ParameterCollection::
GetParameterValueByIDPath(const IDPath& parameterID, std::string& value) const
{  
  std::string sParameterName;
  ValueCountType iItemPos = 0;
  LayerCountType iLayer = 0;

  DispatchParameterIDPath(parameterID,sParameterName,iItemPos,iLayer);
  return GetParameterValue(sParameterName,value,iItemPos,iLayer);
};

Parameter*
ParameterCollection::
GetParameter(const std::string& sParameterName) const
{
  return GetParameter(GetParameterIndex(sParameterName));
};

Parameter*
ParameterCollection::
GetParameter(ParameterCountType index) const
{
  if (index>=Size()) return NULL;
  return m_Parameters[index];
};

bool
ParameterCollection::
SetParameterValue(const std::string& sParameterName, const bool value, const ValueCountType iItemPos, const LayerCountType iLayer)
{  
  ParameterCountType index = GetParameterIndex(sParameterName);
  if (index==-1) return false;
  return m_Parameters[index]->SetParameterValue(value,iItemPos,iLayer);
};

bool
ParameterCollection::
SetParameterValue(const std::string& sParameterName, const double value, const ValueCountType iItemPos, const LayerCountType iLayer)
{  
  ParameterCountType index = GetParameterIndex(sParameterName);
  if (index==-1) return false;
  return m_Parameters[index]->SetParameterValue(value,iItemPos,iLayer);
};
  
bool
ParameterCollection::
SetParameterValue(const std::string& sParameterName, const int value, const ValueCountType iItemPos, const LayerCountType iLayer)
{  
  ParameterCountType index = GetParameterIndex(sParameterName);
  if (index==-1) return false;
  return m_Parameters[index]->SetParameterValue(value,iItemPos,iLayer);
};

bool
ParameterCollection::
SetParameterValue(const std::string& sParameterName, const long value, const ValueCountType iItemPos, const LayerCountType iLayer)
{  
  ParameterCountType index = GetParameterIndex(sParameterName);
  if (index==-1) return false;
  return m_Parameters[index]->SetParameterValue(value,iItemPos,iLayer);
};

bool
ParameterCollection::
SetParameterValue(const std::string& sParameterName, const unsigned long value, const ValueCountType iItemPos, const LayerCountType iLayer)
{  
  ParameterCountType index = GetParameterIndex(sParameterName);
  if (index==-1) return false;
  return m_Parameters[index]->SetParameterValue(value,iItemPos,iLayer);
};

bool
ParameterCollection::
SetParameterValue(const std::string& sParameterName, const std::string& value, const ValueCountType iItemPos, const LayerCountType iLayer)
{  
  ParameterCountType index = GetParameterIndex(sParameterName);
  if (index==-1) return false;
  return m_Parameters[index]->SetParameterValue(value,iItemPos,iLayer);
};

bool
ParameterCollection::
SetParameterValueByIDPath(const IDPath& parameterID, bool& value)
{  
  std::string sParameterName;
  ValueCountType iItemPos = 0;
  LayerCountType iLayer = 0;

  DispatchParameterIDPath(parameterID,sParameterName,iItemPos,iLayer);
  return SetParameterValue(sParameterName,value,iItemPos,iLayer);
};

bool
ParameterCollection::
SetParameterValueByIDPath(const IDPath& parameterID, double& value)
{  
  std::string sParameterName;
  ValueCountType iItemPos = 0;
  LayerCountType iLayer = 0;

  DispatchParameterIDPath(parameterID,sParameterName,iItemPos,iLayer);
  return SetParameterValue(sParameterName,value,iItemPos,iLayer);
};
  
bool
ParameterCollection::
SetParameterValueByIDPath(const IDPath& parameterID, int& value)
{  
  std::string sParameterName;
  ValueCountType iItemPos = 0;
  LayerCountType iLayer = 0;

  DispatchParameterIDPath(parameterID,sParameterName,iItemPos,iLayer);
  return SetParameterValue(sParameterName,value,iItemPos,iLayer);
};

bool
ParameterCollection::
SetParameterValueByIDPath(const IDPath& parameterID, long& value)
{  
  std::string sParameterName;
  ValueCountType iItemPos = 0;
  LayerCountType iLayer = 0;

  DispatchParameterIDPath(parameterID,sParameterName,iItemPos,iLayer);
  return SetParameterValue(sParameterName,value,iItemPos,iLayer);
};

bool
ParameterCollection::
SetParameterValueByIDPath(const IDPath& parameterID, unsigned long& value)
{  
  std::string sParameterName;
  ValueCountType iItemPos = 0;
  LayerCountType iLayer = 0;

  DispatchParameterIDPath(parameterID,sParameterName,iItemPos,iLayer);
  return SetParameterValue(sParameterName,value,iItemPos,iLayer);
};

bool
ParameterCollection::
SetParameterValueByIDPath(const IDPath& parameterID, std::string& value)
{  
  std::string sParameterName;
  ValueCountType iItemPos = 0;
  LayerCountType iLayer = 0;

  DispatchParameterIDPath(parameterID,sParameterName,iItemPos,iLayer);
  return SetParameterValue(sParameterName,value,iItemPos,iLayer);
};

ParameterCollection&
ParameterCollection::
operator = (const ParameterCollection& rParameterCollection)
{
  if (this == &rParameterCollection) return *this;

  Reset();

  for (ParameterCountType i=0; i < rParameterCollection.Size(); i++)
  {
    ParameterPointer smpNewParameter = Parameter::New();
    *(smpNewParameter.GetPointer()) = *(rParameterCollection.GetParameter(i));
    m_Parameters.push_back(smpNewParameter);
  };

  return *this;
};

ParameterCollection::
ParameterCollection() : XMLStreamObject(cXML_ComponentParameters)
{
  Reset();
};

ParameterCollection::
ParameterCollection( const ParameterCollection& rParameterCollection) : XMLStreamObject(cXML_ComponentParameters)
{
  *this = rParameterCollection;
};

ParameterCollection::
~ParameterCollection()
{
  Reset();
};

void
ParameterCollection::
SubElementLoadProcessing(const std::string& rsXMLSubTag, const std::string& rsXMLSubElement, const std::string& rsXMLSubData)
{
  if (rsXMLSubTag==cXML_Parameter)
  {
    ParameterPointer smpNewParameter = Parameter::New();

    try
    {
      smpNewParameter->LoadFromString(rsXMLSubElement);
    }
    catchAllNPassMacro("Unknown error occured while loading parameter for a collection.");

    m_Parameters.push_back(smpNewParameter);
  }
  else if (rsXMLSubTag!=cXML_Text) throwExceptionMacro("Unknown xml tag, unable to load value. Incorrect Tag: " << rsXMLSubTag);
};

std::string
ParameterCollection::
SaveData(const unsigned int& iDepth, bool& bHasSubElements) const
{
  std::string sResult;
  for(ParametersType::const_iterator pos = m_Parameters.begin(); pos != m_Parameters.end(); pos++)
  {
    AddSubElement(sResult,(*pos),iDepth);
  };
  return sResult;
};

}//end of namespace FREE

---