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

#include "freConvert.h"

namespace FREE
{


Parameter::LayerCountType
Parameter::
AddParameterLayer(bool bCopyValue, const std::string& sNewValue)
{
  ParameterLayer::Pointer smpLayer = ParameterLayer::New(ParameterSize(),sNewValue);

  if ((bCopyValue)&(m_Layers.size()>0))
  {
    ParameterLayer::Pointer smpLastLayer = m_Layers.back();
    *(smpLayer.GetPointer()) = *(smpLastLayer.GetPointer());
  }

  m_Layers.push_back(smpLayer);
  return m_Layers.size()-1;
};

void
Parameter::
DeleteParameterLayer(const Parameter::LayerCountType iLayer)
{
  if (iLayer<m_Layers.size())
  {
    m_Layers.erase(m_Layers.begin()+iLayer);
  }
};

void
Parameter::
Reset()
{
  XMLStreamObject::Reset();
  while (m_Layers.size()>0)
  {
    DeleteParameterLayer(0);
  }
};

void
Parameter::
Resize(const Parameter::ValueCountType iNewSize, const std::string& sNewValue)
{
  m_iLayerSize = iNewSize;
  for(LayersType::const_iterator pos = m_Layers.begin(); pos != m_Layers.end(); pos++)
  {
    (*pos)->Resize(iNewSize,sNewValue);
  };
};

void
Parameter::
Resize(const ValueCountType iNewSize, const LayerCountType iNewLayerCount, const std::string& sNewValue)
{
  Reset();
  Resize(iNewSize);
  for (LayerCountType i = 0; i<iNewLayerCount; i++) AddParameterLayer(false,sNewValue);
};

 
Parameter::ValueCountType
Parameter::
ParameterSize() const
{
  return m_iLayerSize;
};

Parameter::LayerCountType
Parameter::
LayerCount() const
{
  return m_Layers.size();
};

ParameterLayer*
Parameter::
GetParameterLayer(const Parameter::LayerCountType iLayer) const
{
  if (iLayer>=LayerCount()) return NULL;
  return m_Layers[iLayer];
};

bool
Parameter::
GetParameterValue(bool& value, const  Parameter::ValueCountType iItemPos, const Parameter::LayerCountType iLayer) const
{
  if (iLayer>=LayerCount()) return false;
  return m_Layers[iLayer]->GetValue(value,iItemPos);
};

bool
Parameter::
GetParameterValue(double& value, const  Parameter::ValueCountType iItemPos, const Parameter::LayerCountType iLayer) const
{
  if (iLayer>=LayerCount()) return false;
  return m_Layers[iLayer]->GetValue(value,iItemPos);
};

bool
Parameter::
GetParameterValue(int& value, const  Parameter::ValueCountType iItemPos, const Parameter::LayerCountType iLayer) const
{
  if (iLayer>=LayerCount()) return false;
  return m_Layers[iLayer]->GetValue(value,iItemPos);
};


bool
Parameter::
GetParameterValue(long& value, const  Parameter::ValueCountType iItemPos, const Parameter::LayerCountType iLayer) const
{
  if (iLayer>=LayerCount()) return false;
  return m_Layers[iLayer]->GetValue(value,iItemPos);
};

bool
Parameter::
GetParameterValue(unsigned long& value, const  Parameter::ValueCountType iItemPos, const Parameter::LayerCountType iLayer) const
{
  if (iLayer>=LayerCount()) return false;
  return m_Layers[iLayer]->GetValue(value,iItemPos);
};

bool
Parameter::
GetParameterValue(std::string& value, const  Parameter::ValueCountType iItemPos, const Parameter::LayerCountType iLayer) const
{
  if (iLayer>=LayerCount()) return false;
  return m_Layers[iLayer]->GetValue(value,iItemPos);
};

bool
Parameter::
SetParameterValue(const bool value, const  Parameter::ValueCountType iItemPos, const Parameter::LayerCountType iLayer)
{
  if (iLayer>=LayerCount()) return false;
  return m_Layers[iLayer]->SetValue(value,iItemPos);
};

bool
Parameter::
SetParameterValue(const double value, const  Parameter::ValueCountType iItemPos, const Parameter::LayerCountType iLayer)
{
  if (iLayer>=LayerCount()) return false;
  return m_Layers[iLayer]->SetValue(value,iItemPos);
};
  
bool
Parameter::
SetParameterValue(const int value, const  Parameter::ValueCountType iItemPos, const Parameter::LayerCountType iLayer)
{
  if (iLayer>=LayerCount()) return false;
  return m_Layers[iLayer]->SetValue(value,iItemPos);
};

bool
Parameter::
SetParameterValue(const long value, const  Parameter::ValueCountType iItemPos, const Parameter::LayerCountType iLayer)
{
  if (iLayer>=LayerCount()) return false;
  return m_Layers[iLayer]->SetValue(value,iItemPos);
};

bool
Parameter::
SetParameterValue(const unsigned long value, const  Parameter::ValueCountType iItemPos, const Parameter::LayerCountType iLayer)
{
  if (iLayer>=LayerCount()) return false;
  return m_Layers[iLayer]->SetValue(value,iItemPos);
};

bool
Parameter::
SetParameterValue(const std::string& value, const  Parameter::ValueCountType iItemPos, const Parameter::LayerCountType iLayer)
{
  if (iLayer>=LayerCount()) return false;
  return m_Layers[iLayer]->SetValue(value,iItemPos);
};

bool
Parameter::
SetParameterLayer(const Parameter::LayerCountType iLayer, const ParameterLayer& rSourceLayer)
{
  if (iLayer>=LayerCount()) return false;
  if (m_Layers[iLayer]->Size()!=rSourceLayer.Size()) return false;

  *(m_Layers[iLayer]) = rSourceLayer;

  return true;
};

Parameter&
Parameter::
operator = (const Parameter& rParameter)
{
  if (this == &rParameter) return *this;

  Resize(rParameter.ParameterSize(),0);

  for (LayerCountType i=0; i < rParameter.LayerCount(); i++)
  {
    *(m_Layers[AddParameterLayer(false)].GetPointer()) = *(rParameter.GetParameterLayer(i));
  };

        m_sParameterName = rParameter.GetParameterName();
  m_sTemplateID = rParameter.GetTemplateID();

  return *this;
};

Parameter::
Parameter(const std::string& sParameterName, const Parameter::ValueCountType iLayerSize, const Parameter::LayerCountType iLayerCount, const std::string& sDefaultValue):XMLStreamObject(FREE::cXML_Parameter)
{
  Reset();
  m_sParameterName = sParameterName;
  m_sTemplateID = "";
  Resize(iLayerSize);
  for (LayerCountType i=0; i<iLayerCount; i++)
  {
    AddParameterLayer(false,sDefaultValue);
  }
};

Parameter::
Parameter():XMLStreamObject(FREE::cXML_Parameter)
{
  m_sParameterName = "Param";
  m_sTemplateID = "";
  Reset();
  Resize(1,1,"");
};

Parameter::Pointer
Parameter::
New(const std::string& sParameterName, const ValueCountType iLayerSize, const LayerCountType iLayerCount, const std::string& sDefaultValue)
{
  Pointer smartPtr;
  Parameter *rawPtr = ::itk::ObjectFactory<Parameter>::Create();
  if(rawPtr == NULL)
  {
    rawPtr = new Parameter;
  }
  smartPtr = rawPtr;
  rawPtr->UnRegister();
  
  rawPtr->SetParameterName(sParameterName);
  rawPtr->Resize(iLayerSize,iLayerCount,sDefaultValue);

  return smartPtr;
};

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

void
Parameter::
SubElementLoadProcessing(const std::string& rsXMLSubTag, const std::string& rsXMLSubElement, const std::string& rsXMLSubData)
{
  if (rsXMLSubTag==cXML_ParameterLayer)
  { //New Layer
    ParameterLayer::Pointer smpNewLayer = ParameterLayer::New();

    try
    {
      smpNewLayer->LoadFromString(rsXMLSubElement);
    }
    catchAllNPassMacro ("Unknown error occured while loading parameter layer.");

    //checking right size of parameter or setting size (first time)
    if (LayerCount()==0) m_iLayerSize = smpNewLayer->Size(); 
    else if (smpNewLayer->Size()!=m_iLayerSize) throwExceptionMacro("Inconsistent layer size within one parameter. Layers of an one parameter must have same count of values. Please check setup file.");
                //If there is no layer m_iLayerSize will be set by an attribute.

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


std::string
Parameter::
SaveData(const unsigned int& iDepth, bool& bHasSubElements) const
{
  std::string sResult;

  //Saving name
  for(LayersType::const_iterator pos = m_Layers.begin(); pos != m_Layers.end(); pos++)
  {
    AddSubElement(sResult,(*pos),iDepth);
  };
  return sResult;
};

void
Parameter::
AttributesLoadProcessing(const AttributesType& rAttributes)
{
  for (AttributesType::const_iterator pos = rAttributes.begin(); pos!= rAttributes.end(); pos++)
  {
    if (pos->first==cXML_ParameterName) m_sParameterName = pos->second;
    else if (pos->first==cXML_TemplateID) m_sTemplateID = pos->second;
                else if (pos->first==cXML_ParameterSize) m_iLayerSize = Convert::ToInt(pos->second);
  };
};

void
Parameter::
SaveAttributes(AttributesSaveListType& rAttributes) const
{
  rAttributes.push_back(AttributesType::value_type(cXML_ParameterName,m_sParameterName));
  if (IsTemplateBased()) rAttributes.push_back(AttributesType::value_type(cXML_TemplateID,m_sTemplateID));
        if ((m_iLayerSize!=1)&&(m_Layers.size()==0)) rAttributes.push_back(AttributesType::value_type(cXML_ParameterSize,Convert::ToStr(m_iLayerSize)));
};

namespace Convert
{
  Parameter::ParameterValueType ToParameterValueType(const std::string& sValue)
  {
    if (sValue==csPVTBool) return Parameter::PVTBool;
    if (sValue==csPVTDouble) return Parameter::PVTDouble;
    if (sValue==csPVTInteger) return Parameter::PVTInteger;
    if (sValue==csPVTLong) return Parameter::PVTLong;
    if (sValue==csPVTULong) return Parameter::PVTULong;
    if (sValue==csPVTURI) return Parameter::PVTURI;
    if (sValue==csPVTIDPath) return Parameter::PVTIDPath;

    return Parameter::PVTString;
  };

  std::string ToStr(const Parameter::ParameterValueType& pt)
  {
    switch (pt)
    {
    case Parameter::PVTBool: return csPVTBool;
    case Parameter::PVTDouble: return csPVTDouble;
    case Parameter::PVTInteger: return csPVTInteger;
    case Parameter::PVTLong: return csPVTLong;
    case Parameter::PVTULong: return csPVTULong;
    case Parameter::PVTURI: return csPVTURI;
    case Parameter::PVTIDPath: return csPVTIDPath;
    default: return csPVTString;
    };
  };
}

}//end of namespace FREE

---