creaImageIOTreeNode.cpp

Go to the documentation of this file.

/*
# ---------------------------------------------------------------------
#
# Copyright (c) CREATIS (Centre de Recherche en Acquisition et Traitement de l'Image 
#                        pour la Santé)
# Authors : Eduardo Davila, Frederic Cervenansky, Claire Mouton
# Previous Authors : Laurent Guigues, Jean-Pierre Roux
# CreaTools website : www.creatis.insa-lyon.fr/site/fr/creatools_accueil
#
#  This software is governed by the CeCILL-B license under French law and 
#  abiding by the rules of distribution of free software. You can  use, 
#  modify and/ or redistribute the software under the terms of the CeCILL-B 
#  license as circulated by CEA, CNRS and INRIA at the following URL 
#  http://www.cecill.info/licences/Licence_CeCILL-B_V1-en.html 
#  or in the file LICENSE.txt.
#
#  As a counterpart to the access to the source code and  rights to copy,
#  modify and redistribute granted by the license, users are provided only
#  with a limited warranty  and the software's author,  the holder of the
#  economic rights,  and the successive licensors  have only  limited
#  liability. 
#
#  The fact that you are presently reading this means that you have had
#  knowledge of the CeCILL-B license and that you accept its terms.
# ------------------------------------------------------------------------
*/

#include <creaImageIOTreeNode.h>
#include <creaImageIOTree.h>
#include <creaImageIOSystem.h>
#include <algorithm>
#include <creaImageIOGimmick.h>

namespace creaImageIO
{
  namespace tree
  {

    //=============================================================
    Node::Node(Node* parent)
      : mParent(parent),//mData(0),
        mChildrenLoaded(false)
    {
        mData.reset();
      if (parent) 
        {
          GimmickDebugMessage(6,"Default Node constructor (level "<<GetLevel()<<")"
                         << std::endl);
          // Insert into parent's children list
          InitializeAttributeMap();
         parent->GetChildrenList().push_back(this);
        }
      else
        {
          GimmickDebugMessage(6,"Default Node constructor without parent"       
                         << std::endl);
        }
    }
    //=============================================================

    //=============================================================
    Node::Node(Node* parent, const AttributeMapType& attr)
     : mParent(parent),//mData(0),
        mChildrenLoaded(false)
    {
        mData.reset();
      GimmickDebugMessage(6,"Node constructor (level "<<GetLevel()<<")"
                     << std::endl);

     if (parent) 
        {
          // Insert into parent's children list
          parent->GetChildrenList().push_back(this);
          // Initialize attributes
          LevelDescriptor::AttributeDescriptorListType::const_iterator a;
          for (a = GetTree()->GetAttributeDescriptorList(GetLevel()).begin();
               a!= GetTree()->GetAttributeDescriptorList(GetLevel()).end();
               ++a)
            {
              std::string v;
              AttributeMapType::const_iterator i = attr.find(a->GetKey());
              if ( i != attr.end() )  
                {
                  v = i->second;
                }
              GimmickDebugMessage(6,"Setting attribute '"<<a->GetName()<<"' = '"
                             <<v<<"'"<<std::endl);
              UnsafeSetAttribute( a->GetKey(), v );
            }
        }
      
    }
    //=============================================================


    //=============================================================
    Node::~Node()
    {
      GimmickDebugMessage(6,"Node destructor"
                     << std::endl);
      ChildrenListType::iterator i;
      for (i=GetChildrenList().begin(); i!=GetChildrenList().end(); i++)
        {
          delete *i;
        }
        mData.reset();
    }
    //=============================================================


    //=============================================================
    void Node::InitializeAttributeMap()
    {
      // Initialize attributes
      LevelDescriptor::AttributeDescriptorListType::const_iterator a;
      for (a = GetTree()->GetAttributeDescriptorList(GetLevel()).begin();
           a!= GetTree()->GetAttributeDescriptorList(GetLevel()).end();
           ++a)
        {
          UnsafeSetAttribute( a->GetKey(), "" );
        }
    }
    //=============================================================

    //=============================================================
    const LevelDescriptor& Node::GetLevelDescriptor() const
    { 
      return GetTree()->GetLevelDescriptor(GetLevel()); 
    }

        //=============================================================

    //=============================================================
        const AttributeDescriptor& Node::GetAttributeDescriptor(const std::string& k)const
        {
                LevelDescriptor::AttributeDescriptorListType::const_iterator a;
      for (a = GetTree()->GetAttributeDescriptorList(GetLevel()).begin();
           a!= GetTree()->GetAttributeDescriptorList(GetLevel()).end();
           ++a)
                {
                
                        if(a->GetKey()==k)
                        {
                                return *a;
                        }
                
                }
                return *a;
        }
    //=============================================================

    //=============================================================
    int Node::RemoveChildrenFromList(Node* node)
    {
      ChildrenListType::iterator i = find(GetChildrenList().begin(),
                                          GetChildrenList().end(),
                                          node);
      if (i != GetChildrenList().end())
        {
          GetChildrenList().erase(i);
        }
        return (int)GetChildrenList().size();
    }
    //=============================================================

    //=============================================================
    const std::string& Node::GetAttribute(const std::string& k) const
    {
      //    std::cout << "this = "<<(void*)this<<std::endl;
      //    std::cout << "mFieldValueMap="<<(void*)(&mFieldValueMap)<<std::endl;
      AttributeMapType::const_iterator i = mAttributeMap.find(k);
      if (i == mAttributeMap.end())
        {
          static std::string def("");
          return def;
          //    CREAIMAGEIO_ERROR("DicomNode::GetFieldValue : no field with key '"<<k<<"'");
        }
      return i->second;
  }
  //=============================================================

  //=============================================================
    void Node::SetAttribute(const std::string& k, 
                                 const std::string& v)
  {
    AttributeMapType::iterator i = mAttributeMap.find(k);
    if (i==mAttributeMap.end())
      {
        std::cout<<"[Gimmick!] Node::SetAttribute : no attribute with key '"
                 <<k<<"'"<<std::endl;
        creaError( "[Gimmick!] Node::SetAttribute : no attribute with key '"
                   <<k<<"'");
      }
    i->second = v;
  }
    //=============================================================

    //=============================================================
    bool Node::Matches(  const AttributeMapType& m ) const
    {
      GimmickDebugMessage(2,"'"<<GetLabel()<<"' matching..."<<std::endl);
      const std::vector<std::string>& id 
        = GetLevelDescriptor().GetIdentifierList();
      std::vector<std::string>::const_iterator i;
      for (i = id.begin(); i != id.end(); ++i)
        {
          if (mAttributeMap.find(*i)->second != m.find(*i)->second ) 
            {
              GimmickDebugMessage(2,"IDENTIFIER '"<<*i<<"' values do not match"<<std::endl);
              return false;
            }
          GimmickDebugMessage(2,"IDENTIFIER '"<<*i<<"' values match"<<std::endl);
        }
      return true;
    }
    //=============================================================
    
    //=============================================================
    void Node::Print() const
    {
      std::string mess;
      for (int i = 0; i<GetLevel(); ++i) mess += "  ";
      mess += "|_ " + GetLabel();
      GimmickMessage(1,mess<<std::endl);
      ChildrenListType::const_iterator j;
      for (j=GetChildrenList().begin(); j!=GetChildrenList().end(); j++)
        {
          (*j)->Print();
        } 
    }
    //=============================================================

    //=============================================================
    std::string Node::GetLabel() const
    {
      std::string l;
      const std::vector<std::string>& label 
        = GetLevelDescriptor().GetLabelList();
      
      std::vector<std::string>::const_iterator i;
      for (i = label.begin(); i != label.end(); )
        {
          GimmickDebugMessage(9,"LABEL '"<<*i<<"'"<<std::endl);
          AttributeMapType::const_iterator j = mAttributeMap.find(*i);
          if (j != mAttributeMap.end())
            {
              l += j->second;
              ++i;
              if (i != label.end()) l += "|";
            }
          else 
            {
              GimmickError("Node::GetLabel() : LABEL attribute '"
                           <<*i
                           <<"' is not in node attribute map (should be!)" );
            }
        }
      if (l.size()==0) l="?";
      return l;
    }
    //=============================================================

  }

}