source: XMLIO_V2/dev/dev_rv/src/node/field.cpp @ 141

#include "field.hpp"

#include "attribute_template_impl.hpp"
#include "object_template_impl.hpp"
#include "group_template_impl.hpp"

#include "node_type.hpp"

namespace xmlioserver
{
   namespace tree
   {
      /// ////////////////////// Définitions ////////////////////// ///

      CField::CField(void)
         : CObjectTemplate<CField>(), CFieldAttributes()
         , baseRefObject(), refObject(), grid(), file(), foperation(NULL)
      { /* Ne rien faire de plus */ }

      CField::CField(const StdString & id)
         : CObjectTemplate<CField>(id), CFieldAttributes()
         , baseRefObject(), refObject(), foperation(NULL)
      { /* Ne rien faire de plus */ }

      CField::~CField(void)
      {
         if (this->foperation == NULL)
            delete this->foperation;
      }

      void CField::setRelFile(const boost::shared_ptr<CFile> _file)
      { this->file = _file; }

      //----------------------------------------------------------------

      StdString CField::GetName(void)   { return (StdString("field")); }
      StdString CField::GetDefName(void){ return (CField::GetName()); }

      boost::shared_ptr<CGrid> CField::getRelGrid(void) const
      { return (this->grid); }

      boost::shared_ptr<CFile> CField::getRelFile(void) const
      { return (this->file); }

      boost::shared_ptr<CField> CField::getDirectFieldReference(void) const
      {
         if (this->field_ref.isEmpty())
            return (this->getBaseFieldReference());

         if (! CObjectFactory::HasObject<CField>(this->field_ref.getValue()))
            ERROR("CField::getDirectFieldReference(void)",
                  << "[ ref_name = " << this->field_ref.getValue() << "]"
                  << " invalid field name !");

         return (CObjectFactory::GetObject<CField>(this->field_ref.getValue()));
      }

      const boost::shared_ptr<CField>
         CField::getBaseFieldReference(void) const { return (baseRefObject); }

      const std::vector<boost::shared_ptr<CField> > &
         CField::getAllReference(void) const { return (refObject); }

      const StdString & CField::getBaseFieldId(void) const
      { return (this->getBaseFieldReference()->getId()); }

      bool CField::hasDirectFieldReference(void) const
      { return (!this->field_ref.isEmpty()); }

      //----------------------------------------------------------------

      void CField::solveRefInheritance(void)
      {
         std::set<CField *> sset;
         boost::shared_ptr<CField> refer_sptr;
         CField * refer_ptr = this;
         this->baseRefObject = CObjectFactory::GetObject<CField>(this);
         while (refer_ptr->hasDirectFieldReference())
         {
            refer_sptr = refer_ptr->getDirectFieldReference();
            refer_ptr  = refer_sptr.get();

            if(sset.end() != sset.find(refer_ptr))
            {
               DEBUG (<< "Dépendance circulaire stoppée pour l'objet de type CField sur "
                      << "\"" + refer_ptr->getId() + "\" !");
               break;
            }

            SuperClassAttribute::setAttributes(refer_ptr);
            sset.insert(refer_ptr);
            baseRefObject = refer_sptr;
            refObject.push_back(refer_sptr);
         }
      }

      //----------------------------------------------------------------

      void  CField::solveOperation(void)
      {
         // TODO : à compléter;
      }

      //----------------------------------------------------------------

      void CField::solveGridReference(void)
      {
         boost::shared_ptr<CDomain> domain;
         boost::shared_ptr<CAxis> axis;

         if (!domain_ref.isEmpty())
         {
            if (CObjectFactory::HasObject<CDomain>(domain_ref.getValue()))
               domain = CObjectFactory::GetObject<CDomain>(domain_ref.getValue()) ;
            else
               ERROR("CField::solveGridReference(void)",
                     << "Référence au domaine nommé \'"
                     << domain_ref.getValue() << "\' incorrecte") ;
         }

         if (!axis_ref.isEmpty())
         {
            if (CObjectFactory::HasObject<CAxis>(axis_ref.getValue()))
               axis = CObjectFactory::GetObject<CAxis>(axis_ref.getValue()) ;
            else
               ERROR("CField::solveGridReference(void)",
                     << "Référence à l'axe nommé \'"
                     << axis_ref.getValue() <<"\' incorrecte") ;
         }

         if (!grid_ref.isEmpty())
         {
            if (CObjectFactory::HasObject<CGrid>(grid_ref.getValue()))
               this->grid = CObjectFactory::GetObject<CGrid>(grid_ref.getValue()) ;
            else
               ERROR("CField::solveGridReference(void)",
                     << "Référence à la grille nommée \'"
                     << grid_ref.getValue() << "\' incorrecte");
            if (!domain_ref.isEmpty())
               DEBUG(<< "Définition conjointe de la grille "
                     << "et du domaine, la grille prévaut..." );
            if (!axis_ref.isEmpty())
               DEBUG(<< "Définition conjointe de la grille "
                     << "et de l'axe vertical, la grille prévaut...") ;
         }
         else
         {
            if (!domain_ref.isEmpty())
            {
               if (!axis_ref.isEmpty())
               {
                  this->grid = CGrid::CreateGrid(domain, axis) ;
                  this->grid_ref.setValue(this->grid->getId());
               }
               else
               {
                  this->grid = CGrid::CreateGrid(domain) ;
                  this->grid_ref.setValue(this->grid->getId());
               }
            }
            else
            {
               ERROR("CField::solveGridReference(void)",
                     << "Le domaine horizontal pour le champ X n'est pas défini");
            }
         }
         grid->solveReference() ;
      }
   } // namespace tree

   ///-------------------------------------------------------------------

   template <>
      void CGroupTemplate<CField, CFieldGroup, CFieldAttributes>::solveRefInheritance(void)
   {
      if (this->group_ref.isEmpty()) return;
      StdString gref = this->group_ref.getValue();

      if (!CObjectFactory::HasObject<CFieldGroup>(gref))
         ERROR("CGroupTemplate<CField, CFieldGroup, CFieldAttributes>::solveRefInheritance(void)",
               << "[ gref = " << gref << "]"
               << " invalid group name !");

      boost::shared_ptr<CFieldGroup> group
               = CObjectFactory::GetObject<CFieldGroup>(gref);
      boost::shared_ptr<CFieldGroup> owner
               = CObjectFactory::GetObject<CFieldGroup>(boost::polymorphic_downcast<CFieldGroup*>(this));

      std::vector<boost::shared_ptr<CField> > allChildren = group->getAllChildren();
      BOOST_FOREACH(boost::shared_ptr<CField> child, allChildren)
         if (child->hasId())
            CGroupFactory::CreateChild(owner)->field_ref.setValue(child->getId());
   }

   ///-------------------------------------------------------------------

} // namespace xmlioserver