freXMLValueSet.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: freXMLValueSet.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 "freXMLValueSet.h"
#include "freExceptions.h"
#include "freConvert.h"

namespace FREE
{



void
XMLValueSet::
Reset(const XMLValueSet::ValueCountType iValueCount, const std::string& sNewValue)
{
  Reset();
  m_Values.resize(iValueCount, sNewValue);
};

void
XMLValueSet::
Resize(const XMLValueSet::ValueCountType iNewSize, const std::string& sNewValue)
{
  m_Values.resize(iNewSize, sNewValue);
};

XMLValueSet::ValueCountType
XMLValueSet::
Size() const
{
  return m_Values.size();
};

bool
XMLValueSet::
GetValue(bool& value, XMLValueSet::ValueCountType iItemPos) const
{
  std::string  sValue;
  bool bResult = GetValue(sValue,iItemPos);

  if (bResult) value = Convert::ToBool(sValue);
  return bResult;
};

bool
XMLValueSet::
GetValue(double& value, XMLValueSet::ValueCountType iItemPos) const
{
  std::string  sValue;
  bool bResult = GetValue(sValue,iItemPos);

  if (bResult) value = Convert::ToDouble(sValue);
  return bResult;
};
  
bool
XMLValueSet::
GetValue(float& value, XMLValueSet::ValueCountType iItemPos) const
{
  std::string  sValue;
  bool bResult = GetValue(sValue,iItemPos);

  if (bResult) value = Convert::ToFloat(sValue);
  return bResult;
};

bool
XMLValueSet::
GetValue(int& value, XMLValueSet::ValueCountType iItemPos) const
{
  std::string  sValue;
  bool bResult = GetValue(sValue,iItemPos);

  if (bResult) value = Convert::ToInt(sValue);
  return bResult;
};

bool
XMLValueSet::
GetValue(unsigned int& value, XMLValueSet::ValueCountType iItemPos) const
{
  std::string  sValue;
  bool bResult = GetValue(sValue,iItemPos);

  if (bResult) value = Convert::ToUInt(sValue);
  return bResult;
};

bool
XMLValueSet::
GetValue(long& value, XMLValueSet::ValueCountType iItemPos) const
{
  std::string  sValue;
  bool bResult = GetValue(sValue,iItemPos);

  if (bResult) value = Convert::ToLong(sValue);
  return bResult;
};

bool
XMLValueSet::
GetValue(unsigned long& value, XMLValueSet::ValueCountType iItemPos) const
{
  std::string  sValue;
  bool bResult = GetValue(sValue,iItemPos);

  if (bResult) value = Convert::ToULong(sValue);
  return bResult;
};

bool
XMLValueSet::
GetValue(std::string& value, XMLValueSet::ValueCountType iItemPos) const
{
  if (iItemPos>=m_Values.size()) return false;

  value = m_Values[iItemPos];
  return true;
};

bool
XMLValueSet::
SetValue(const bool value, XMLValueSet::ValueCountType iItemPos)
{
  return SetValue(Convert::ToStr(value), iItemPos);
};

bool
XMLValueSet::
SetValue(const double value, ValueCountType iItemPos)
{
  return SetValue(Convert::ToStr(value), iItemPos);
};
  
bool
XMLValueSet::
SetValue(const float value, ValueCountType iItemPos)
{
  return SetValue(Convert::ToStr(value), iItemPos);
};

bool
XMLValueSet::
SetValue(const int value, ValueCountType iItemPos)
{
  return SetValue(Convert::ToStr(value), iItemPos);
};

bool
XMLValueSet::
SetValue(const unsigned int value, ValueCountType iItemPos)
{
  return SetValue(Convert::ToStr(value), iItemPos);
};

bool
XMLValueSet::
SetValue(const long value, ValueCountType iItemPos)
{
  return SetValue(Convert::ToStr(value), iItemPos);
};

bool
XMLValueSet::
SetValue(const unsigned long value, ValueCountType iItemPos)
{
  return SetValue(Convert::ToStr(value), iItemPos);
};

bool
XMLValueSet::
SetValue(const std::string& value, ValueCountType iItemPos)
{
  if (iItemPos>=m_Values.size()) return false;

  m_Values[iItemPos] = value;
  return true;
};

XMLValueSet&
XMLValueSet::
operator = (const XMLValueSet& valueSet)
{
  if (this == &valueSet) return *this;

  m_Values.assign(valueSet.m_Values.begin(),valueSet.m_Values.end());

  return *this;
};

XMLValueSet::
XMLValueSet(const ValueCountType iValueCount, const std::string& sNewValue) : XMLStreamObject("XMLValueSet")
{
  Reset(iValueCount,sNewValue);
};

XMLValueSet::
XMLValueSet() : XMLStreamObject("XMLValueSet")
{
  Reset(0,"");
};

XMLValueSet::
XMLValueSet( const XMLValueSet& valueSet) : XMLStreamObject(valueSet.GetXMLTag())
{
  *this = valueSet;
};

XMLValueSet::
~XMLValueSet()
{
};

void
XMLValueSet::
Reset()
{
  XMLStreamObject::Reset();
  m_Values.clear();
};


void
XMLValueSet::
SubElementLoadProcessing(const std::string& rsXMLSubTag, const std::string& rsXMLSubElement, const std::string& rsXMLSubData)
{
  if (rsXMLSubTag == cXML_ParameterValue)
  {
    m_Values.push_back(rsXMLSubData);
  }
  else if (rsXMLSubTag!=cXML_Text) throwExceptionMacro("Unknown xml tag, unable to load value. Incorrect Tag: "<< rsXMLSubTag);
};

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

  for(ValuesType::const_iterator pos = m_Values.begin(); pos != m_Values.end(); pos++)
  {
    AddSubElement(sData,cXML_ParameterValue,*pos,iDepth);
  }
  return sData;
};

}//end of namespace FREE

---