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

namespace FREE
{


StatisticValueDefinition*
StatisticDictionary::
AddValueDefinition()
{
  StatisticValueDefinition::Pointer smpNewEntry = StatisticValueDefinition::New();

  if (this->m_ValueDefs.Size()>0) smpNewEntry->SetRefID(m_ValueDefs.GetElement(m_ValueDefs.Size()-1)->GetRefID()+1);
  else smpNewEntry->SetRefID(1);
  this->m_ValueDefs.AddElement(smpNewEntry);

  return smpNewEntry;
};

StatisticValueDefinition*
StatisticDictionary::
AddValueDefinition(const std::string& sIDPath, const std::string& sName, const std::string& sDescription)
{
  StatisticValueDefinition::Pointer smpNewEntry = AddValueDefinition();
  smpNewEntry->SetIDPath(sIDPath);
  smpNewEntry->SetName(sName);
  smpNewEntry->SetDescription(sDescription);
  return smpNewEntry;
};

StatisticValueDefinition*
StatisticDictionary::
GetValueDefinitionByName(const std::string& sIDPath, const std::string& sName)
{
  for (ValueDefinitionsType::ElementsCountType index = 0; index< this->m_ValueDefs.Size(); index++)
  {
    StatisticValueDefinition::Pointer smpEntry = m_ValueDefs.GetElement(index);
    if ((smpEntry->GetName() == sName)&&(smpEntry->GetIDPath() == sIDPath)) return smpEntry;
  }
  return NULL;
};

StatisticValueDefinition*
StatisticDictionary::
GetValueDefinitionByIndex(const IndexType& index)
{
  return m_ValueDefs.GetElement(index);
};

StatisticValueDefinition*
StatisticDictionary::
GetValueDefinitionByID(const ValueIDType& id)
{
  for (ValueDefinitionsType::ElementsCountType index = 0; index< this->m_ValueDefs.Size(); index++)
  {
    StatisticValueDefinition::Pointer smpEntry = m_ValueDefs.GetElement(index);
    if (smpEntry->GetRefID() == id) return smpEntry;
  }
  return NULL;
};

StatisticDictionary::ValueIDType
StatisticDictionary::
GetValueDefinitionIDByName(const std::string& sIDPath, const std::string& sName)
{
  StatisticValueDefinition* pEntry = GetValueDefinitionByName(sIDPath,sName);
  if (pEntry) return pEntry->GetRefID();

  return 0;
};

StatisticEntryDefinition*
StatisticDictionary::
AddEntryDefinition()
{
  StatisticEntryDefinition::Pointer smpNewEntry = StatisticEntryDefinition::New();

  if (this->m_EntryDefs.Size()>0) smpNewEntry->SetRefID(m_EntryDefs.GetElement(m_EntryDefs.Size()-1)->GetRefID()+1);
  else smpNewEntry->SetRefID(1);
  this->m_EntryDefs.AddElement(smpNewEntry);

  return smpNewEntry;
};

StatisticEntryDefinition*
StatisticDictionary::
AddEntryDefinition(const std::string& sIDPath, const std::string& sName, const std::string& sControllerID, const std::string& sDescription)
{
  StatisticEntryDefinition::Pointer smpNewEntry = AddEntryDefinition();
  smpNewEntry->SetIDPath(sIDPath);
  smpNewEntry->SetName(sName);
  smpNewEntry->SetDescription(sDescription);
  smpNewEntry->SetControllerID(sControllerID);
  return smpNewEntry;
};

StatisticEntryDefinition*
StatisticDictionary::
GetEntryDefinitionByName(const std::string& sIDPath, const std::string& sName)
{
  for (EntryDefinitionsType::ElementsCountType index = 0; index< this->m_EntryDefs.Size(); index++)
  {
    StatisticEntryDefinition::Pointer smpEntry = m_EntryDefs.GetElement(index);
    if ((smpEntry->GetName() == sName)&&(smpEntry->GetIDPath() == sIDPath)) return smpEntry;
  }
  return NULL;
};

StatisticEntryDefinition*
StatisticDictionary::
GetEntryDefinitionByIndex(const IndexType& index)
{
  return m_EntryDefs.GetElement(index);
};

StatisticEntryDefinition*
StatisticDictionary::
GetEntryDefinitionByID(const EntryIDType& id)
{
  for (EntryDefinitionsType::ElementsCountType index = 0; index< this->m_EntryDefs.Size(); index++)
  {
    StatisticEntryDefinition::Pointer smpEntry = m_EntryDefs.GetElement(index);
    if (smpEntry->GetRefID() == id) return smpEntry;
  }
  return NULL;
};

StatisticDictionary::EntryIDType
StatisticDictionary::
GetEntryDefinitionIDByName(const std::string& sIDPath, const std::string& sName)
{
  StatisticEntryDefinition* pEntry = GetEntryDefinitionByName(sIDPath,sName);
  if (pEntry) return pEntry->GetRefID();

  return 0;
};

StatisticDictionary::
StatisticDictionary():XMLStreamObject(XMLTags::StatisticDictionary),
                      m_EntryDefs(XMLTags::StatisticEntryDefinitions),
                      m_ValueDefs(XMLTags::StatisticValueDefinitions)
{
  Reset();
};

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

void
StatisticDictionary::
Reset()
{
  m_EntryDefs.Reset();
  m_ValueDefs.Reset();
};

void
StatisticDictionary::
SubElementLoadProcessing(const std::string& rsXMLSubTag, const std::string& rsXMLSubElement, const std::string& rsXMLSubData)
{
  if (rsXMLSubTag == XMLTags::StatisticValueDefinitions)
  {
    m_ValueDefs.LoadFromString(rsXMLSubElement);
  }
  else if (rsXMLSubTag == XMLTags::StatisticEntryDefinitions)
  {
    m_EntryDefs.LoadFromString(rsXMLSubElement);
  }
};

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

  bHasSubElements = true;
        AddSubElement(result,&m_ValueDefs,iDepth);
        AddSubElement(result,&m_EntryDefs,iDepth);

  return result;
}

} //end of namespace FREE

---