freStatisticEntry.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: freStatisticEntry.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 "freStatisticEntry.h"
#include "freStatisticData.h"

#include "freConvert.h"

namespace FREE
{



const StatisticEntry::ReferenceIDType StatisticEntry::cUndefinedRef = 0;

StatisticEntry& StatisticEntry::operator = (const StatisticEntry& entry)
{
  if (this == &entry) return *this;

  TimeStampedObject::operator =(entry);

  //Copy values;
  for (ValuesType::const_iterator pos = entry.m_Values.begin(); pos != entry.m_Values.end(); pos++)
  {
    StatisticValue newValue(*pos);
    m_Values.push_back(newValue);
  }

  //Copy entries;
  for (EntriesType::const_iterator pos = entry.m_Entries.begin(); pos != entry.m_Entries.end(); pos++)
  {
    StatisticEntry::Pointer smpChild = m_pData->CreateEntry();
    smpChild->operator = (*(*pos));
    m_Entries.push_back(smpChild);
  }

  return *this;
};

StatisticEntry::Pointer
StatisticEntry::
CreateChildEntry()
{
  if (!m_pData) throwExceptionMacro("Error. Cannot create a statistic entry, parent entry has no StatisticData defined.");

  if (IsClosed())
  {
    return PostCreateChildEntry();
  }
  else
  {
    StatisticEntry::Pointer smpChild = m_pData->CreateEntry();
    smpChild->SetCreationTimeStamp();

    //if there is a preceeding sibling, close it
    if (m_Entries.size()!=0)
    {
      m_Entries.back()->CloseEntry();
    }

    m_Entries.push_back(smpChild);
    m_pData->OpenEntry(smpChild->GetID());

    return smpChild;
  }
};

StatisticEntry::Pointer
StatisticEntry::
PostCreateChildEntry()
{
  if (!m_pData) throwExceptionMacro("Error. Cannot create a statistic entry, parent entry has no StatisticData defined.");

  StatisticEntry::Pointer smpChild = m_pData->CreateEntry();

  //Set creation time
  if (m_Entries.size()==0)
  { //no preceeding siblings
    smpChild->SetCreationTimeStamp(this->GetCreationTimeStamp());
  }
  else
  { //equals the closing time stamp of the preceeding sibling, so close sibling and get stamp
    m_Entries.back()->CloseEntry();
    smpChild->SetCreationTimeStamp(m_Entries.back()->GetClosingTimeStamp());
  }

  //Set closing time
  if (IsClosed())
  {
    smpChild->SetClosingTimeStamp(this->GetClosingTimeStamp());
  }
  else
  {
    smpChild->SetClosingTimeStamp();
  }

  m_pData->OpenEntry(smpChild->GetID());
  m_Entries.push_back(smpChild);

  return smpChild;
};

void
StatisticEntry::
CloseEntry()
{
  for (EntriesType::const_iterator pos = m_Entries.begin(); pos != m_Entries.end(); pos++)
  {
    (*pos)->CloseEntry();
  }

  if (!IsClosed()) this->SetClosingTimeStamp();

  m_pData->CloseEntry(m_ID);
};

StatisticEntry::
StatisticEntry(const IDType& id, clock_t& stampOffset, StatisticData* pData):TimeStampedObject(stampOffset,XMLTags::StatisticEntry)
{
  if (!pData) throwExceptionMacro("Error. Cannot create a statistic entry, no StatisticData defined.");
  m_ID = id;
  m_pData = pData;
};

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

void
StatisticEntry::
Reset()
{
  TimeStampedObject::Reset();
  m_Values.clear();
  m_Entries.clear();
};

StatisticValue&
StatisticEntry::
AddValue(const std::string& sValue, const StatisticValue::ReferenceIDType& refID)
{
  StatisticValue value(sValue,refID);
  m_Values.push_back(value);
  return m_Values.back();
};

void
StatisticEntry::
SubElementLoadProcessing(const std::string& rsXMLSubTag, const std::string& rsXMLSubElement, const std::string& rsXMLSubData)
{
  if (rsXMLSubTag == XMLTags::StatisticValue)
  {
    StatisticValue newValue("");
    newValue.LoadFromString(rsXMLSubElement);
    m_Values.push_back(newValue);
  }
  else if (rsXMLSubTag == XMLTags::StatisticEntry)
  {
    StatisticEntry::Pointer smpChild = m_pData->CreateEntry();
    smpChild->LoadFromString(rsXMLSubElement);
    m_Entries.push_back(smpChild);
  }
  else TimeStampedObject::SubElementLoadProcessing(rsXMLSubTag, rsXMLSubElement, rsXMLSubData);
};

std::string
StatisticEntry::
SaveData(const unsigned int& iDepth, bool& bHasSubElements) const
{
  std::string result;
  //values
  for (ValuesType::const_iterator pos = m_Values.begin(); pos != m_Values.end(); pos++)
  {
                AddSubElement(result,&(*pos),iDepth);
  }
  //entries
  for (EntriesType::const_iterator pos = m_Entries.begin(); pos != m_Entries.end(); pos++)
  {
                AddSubElement(result,*pos,iDepth);
  }
  return result;
};

void
StatisticEntry::
AttributesLoadProcessing(const AttributesType& rAttributes)
{
  AttributesType::const_iterator pos = rAttributes.find(XMLTags::StatisticEntryRef);
  if (pos == rAttributes.end()) m_RefID = cUndefinedRef;
  else m_RefID = Convert::ToInt(pos->second);

  TimeStampedObject::AttributesLoadProcessing(rAttributes);
};

void
StatisticEntry::
SaveAttributes(AttributesSaveListType& rAttributes) const
{
  rAttributes.push_back(AttributesSaveListType::value_type(XMLTags::StatisticEntryRef,Convert::ToStr(m_RefID)));
  rAttributes.push_back(AttributesSaveListType::value_type(XMLTags::StatisticEntryID, Convert::ToStr(m_ID)));
  
  TimeStampedObject::SaveAttributes(rAttributes);
}; 


} //end of namespace FREE

---