XMLTag.h

Go to the documentation of this file.

/*
 * Copyright (C) 2009 by Ulrich Friedrich Klank <klank@in.tum.de>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */


/************************************************************************
                        XMLTag.h - Copyright klank


**************************************************************************/


#ifndef XMLTAG_H
#define XMLTAG_H

//#include "RelPoseFactory.h"
#include "Signature.h"
#include "AlgorithmEval.h"
#include "Sensor.h"
#include <map>

typedef struct _xmlTextWriter xmlTextWriter;
typedef struct _xmlTextReader xmlTextReader;
typedef struct _xmlDoc xmlDoc;
typedef unsigned char xmlChar;
typedef struct _xmlNode xmlNode;

#define XML_NODE_STD_VECTOR "std_vector"
#define XML_NODE_STD_MAP "std_map"
#define XML_NODE_STD_PAIR "std_pair"
#define XML_NODE_STD_MAPENTRY "mapentry"
#define XML_NODE_INT "int"
#define XML_NODE_DOUBLE "double"
#define XML_NODE_ULONG "ulong"
#define XML_NODE_STRING "std_string"
#define XML_NODE_MATRIX "newmat_Matrix"

#define XML_ATTRIBUTE_ROWS "rows"
#define XML_ATTRIBUTE_COLS "cols"


namespace cop
{

  LocateAlgorithm* LocAlgFactory(XMLTag* tag);

  template<typename T> class AlgorithmEval;

  /**********************************************************************************************/
  class XMLTag
  {
  public:

    // Constructors/Destructors
    //


    XMLTag ( std::string name);

    virtual ~XMLTag ( );


  /****************************************************************************/
    void WriteToFile(const std::string& stFile, XMLTag** fileReference = NULL) const;
  /****************************************************************************/
   char* WriteToString();
  /****************************************************************************/
   void FreeAfterWriteToString();

  /****************************************************************************/
    static XMLTag* ReadFromFile(const std::string &stFile);
  /****************************************************************************/
    XMLTag* Clone() const;

  /****************************************************************************/
    virtual void Write(xmlTextWriter* pWriter) const;
  /****************************************************************************/
    static XMLTag* Read(xmlTextReader* pReader);
  /****************************************************************************/
    template<typename T> static XMLTag* Tag(std::vector<T> vector, std::string name = "")
    {
      XMLTag* tag = new XMLTag(name.compare("") == 0 ? XML_NODE_STD_VECTOR : name);
  #ifdef WIN32
      std::vector<T>::const_iterator iter;
      for(iter = vector.begin(); iter != vector.end(); iter++)
      {
        tag->AddChild(XMLTag::Tag((*iter)));
      }
  #else
      for(unsigned int i = 0; i < vector.size(); i++)
      {
        tag->AddChild(XMLTag::Tag(vector[i]));
      }
  #endif
      return tag;
    }

 template<typename T1, typename T2> static XMLTag* Tag(std::map< T1, T2 > map, std::string name = "")
    {
      XMLTag* tag = new XMLTag(name.compare("") == 0 ? XML_NODE_STD_MAP : name);
      typename std::map< T1, T2 >::iterator iter;
      for(iter = map.begin(); iter != map.end(); iter++)
      {
        XMLTag* childTag = new XMLTag(XML_NODE_STD_MAPENTRY);
        childTag->AddChild(XMLTag::Tag((*iter).first));
        childTag->AddChild(XMLTag::Tag((*iter).second));
        tag->AddChild(childTag);
      }
      return tag;
    }

    template<typename T1, typename T2> static XMLTag* Tag(std::pair<T1, T2> p, std::string name = "")
    {
      XMLTag* tag = new XMLTag(name.compare("") == 0 ? XML_NODE_STD_PAIR : name);
      tag->AddChild(XMLTag::Tag(p.first));
      tag->AddChild(XMLTag::Tag(p.second));
      return tag;
    }

    template<typename T3> static XMLTag* Tag(AlgorithmEval<T3> eval, std::string name = "")
    {
      return eval.Save();
    }


    static XMLTag* Tag(int n, std::string name = "");
    static XMLTag* Tag(long n, std::string name = "");
    static XMLTag* Tag(unsigned long n, std::string name = "");
    static XMLTag* Tag(double d, std::string name = "");
    static XMLTag* Tag(std::string value, std::string name = "");
    static XMLTag* Tag(Elem* elem, std::string name = "");
    static XMLTag* Tag(Algorithm<ImprovedPose>* alg, std::string name = "");
    static XMLTag* Tag(Algorithm<std::vector<Signature*> >* alg, std::string name = "");
    static XMLTag* Tag(Algorithm<std::vector<RelPose* > >* alg, std::string name = "");
    static XMLTag* Tag(Algorithm<Descriptor*>* alg, std::string name = "");
    static XMLTag* Tag(Sensor* sensor, std::string name = "");
    static XMLTag* Tag(const Matrix& alg, std::string name = "");


  /****************************************************************************/
    template<typename T>
    static T Load(XMLTag* tag, T* t )
    {
      throw "Load Failed: Expected type has no loading function implemented";
    };

    template<typename T>
     static std::vector<T> Load(XMLTag* tag, std::vector<T>*  )
    {
      std::vector<T> vectorTemp;
      for(unsigned int i = 0; i < tag->CountChildren(); i++)
      {
        try
        {
          if(tag->GetChild(i)->GetName().compare("comment") != 0)
            vectorTemp.push_back(Load(tag->GetChild(i), (T*)NULL));
          else
          {
            printf("Comment in vector\n");
          }
        }
        catch(char const* text)
        {
          printf("Error reading a vector: %s\n", text);
          /* Do nothing, try to get the others*/
        }
        catch(...)
        {
          printf("Error reading a vector.\n");
          /* Do nothing, try to get the others*/
        }
      }
      return vectorTemp;
    };

    template<typename T1, typename T2>
     static std::map<T1, T2> Load(XMLTag* tag, std::map<T1, T2>* map)
    {
      std::map<T1, T2> mapTemp;
      if(tag != NULL)
      {
        for(unsigned int i = 0; i < tag->CountChildren(); i++)
        {
          XMLTag* mapentry =  tag->GetChild(i);
          if(mapentry == NULL)
            continue;
          try
          {
            T1 key;
            key = Load(mapentry->GetChild(0), (T1*)NULL);
            mapTemp[key] = Load(mapentry->GetChild(1), (T2*)NULL);
          }
          catch(char const* text)
          {
            printf("Error reading a map: %s\n", text);
            /* Do nothing, try to get the others*/
          }
          catch(...)
          {
            printf("Error reading a map.\n");
            /* Do nothing, try to get the others*/
          }
        }
      }
      return mapTemp;
    };


    template<typename T1, typename T2>
    static std::pair<T1, T2> Load(XMLTag* tag, std::pair<T1, T2>*  )
    {
      std::pair<T1, T2> p;
      int childCount = tag->CountChildren();
      if(childCount > 0)
        p.first = Load(tag->GetChild(0), (T1*)NULL);
      if(childCount > 1)
        p.second = Load(tag->GetChild(1), (T2*)NULL);

      return p;
    };

    template<typename T3> static AlgorithmEval<T3> Load(XMLTag* tag, AlgorithmEval<T3>*)
    {
      return AlgorithmEval<T3>(tag);
    }

    static int Load(XMLTag* tag, int* )
    {
      if(tag == NULL)
        return 0;
      return  tag->GetCDataInt();
    };

    static int Load(XMLTag* tag, unsigned long* )
    {
      if(tag == NULL)
        return 0;
      return  tag->GetCDataUlong();
    };

    static double Load(XMLTag* tag,double *)
    {
      if(tag == NULL)
        return 0.0;
      return tag->GetCDataDouble();
    };

    static std::string Load(XMLTag* tag, std::string *)
    {
      if(tag == NULL)
        return "";
      return tag->GetCDataST();
    };

    static Elem* Load(XMLTag* tag, Elem**  )
    {
      if(tag == NULL)
        return NULL;
      return Elem::ElemFactory(tag);
    };

    static Algorithm<std::vector<RelPose*> >* Load(XMLTag* tag, Algorithm<std::vector<RelPose*> >** )
    {
      if(tag == NULL)
        return NULL;
      return (Algorithm<std::vector<RelPose*> >*)LocateAlgorithm::LocAlgFactory(tag);
    };

    static Algorithm<ImprovedPose>* Load(XMLTag* tag, Algorithm<ImprovedPose>** )
    {

      if(tag == NULL)
        return NULL;
      return (Algorithm<ImprovedPose>*)ProveAlgorithm::ProveAlgFactory(tag);
    };

    static Algorithm<Descriptor*>* Load(XMLTag* tag, Algorithm<Descriptor*>** )
    {
      if(tag == NULL)
        return NULL;
      return (Algorithm<Descriptor*>*)RefineAlgorithm::RefineAlgFactory(tag);
    };


    static Algorithm<std::vector<Signature*> >* Load(XMLTag* tag, Algorithm<std::vector<Signature*> >** )
    {
      if(tag == NULL)
        return NULL;
      return ( Algorithm<std::vector<Signature*> >*)AttentionAlgorithm::AttentionAlgFactory(tag);
    };

    static Sensor* Load(XMLTag* tag, Sensor** )
    {
      if(tag == NULL)
      {
        printf("Tag for laoding a sensor equals NULL\n");
        return NULL;
      }
      return Sensor::SensorFactory(tag);
    };

    /*static SemMapElement* Load(XMLTag* tag, SemMapElement** )
    {
      if(tag == NULL)
        return NULL;
      return SemMapElement::SemMapElementFactory(tag);
    };*/

  /****************************************************************************/
    static Matrix Load(XMLTag* tag, Matrix* m);

  /****************************************************************************/
    void AddProperty(const std::string& name, const std::string& value);
  /****************************************************************************/
    void AddProperty(const std::string &name, const unsigned long &value);
    void AddProperty(const std::string &name, const long &value);
  /****************************************************************************/
    void AddProperty(const std::string& name, const int &value);
  /****************************************************************************/
    void AddProperty(const std::string& name, const double &value);

  /****************************************************************************/
    void SetCData(const int &value);
    void SetCData(const long &value);
    void SetCData(const unsigned long &value);
  /****************************************************************************/
    void SetCData(const double &value);
  /****************************************************************************/
    void SetCData(const std::string &value);

  /****************************************************************************/
    int                 GetCDataInt() const;
    unsigned long GetCDataUlong() const;
    double              GetCDataDouble() const;
    std::string GetCDataST() const;


  /****************************************************************************/
    std::string GetProperty(const std::string& name, std::string defaultValue = "");
    double GetPropertyDouble(const std::string& name, double defaultValue = 0.0);
    int GetPropertyInt(const std::string& name, int defaultValue = 0);


  /****************************************************************************/
    int AddChild(XMLTag* child, int position = -1);
     /****************************************************************************/
    void ReplaceChild(XMLTag* child, int position);
  /****************************************************************************/
    unsigned int CountChildren() const;
  /****************************************************************************/
    void RemoveChild(const unsigned int &position);
  /****************************************************************************/
   void RemoveChild(const std::string &name);

  /****************************************************************************/
    XMLTag* GetChild(const unsigned int &position);
    XMLTag* GetChild(const std::string &name);
    XMLTag* GetChild(const std::string& name, int innerindex);

  /****************************************************************************/
    std::string& GetName(){return m_name;}
    void SetName(std::string name){m_name = name;}

    //static public Methods
    static unsigned int OldTag()
    {
      return 0;
    }

    unsigned long date();
    //
    //Methods
    //
    int getQueryType();

    /****************************************************************************/
    std::vector<std::string> GetSubFilenames();
    void ReplaceSubFilenames(std::string global_path);
    protected:


    private:

     /****************************************************************************/
      void Touch();


     /****************************************************************************/
     void GetSubFilenames(std::vector<std::string> &strings);
    /****************************************************************************/
      void DocWrite(xmlNode* n) const;

    // Private attributes
    //
    unsigned long                                                                  m_lastChanged;
    std::vector<XMLTag*>                                         m_children;
    std::string                                                                    m_cData;
    std::string                                                                    m_name;
    std::map<std::string, std::string>   m_properties;

    xmlDoc                               *m_doc;
    xmlChar                              *m_xmlbuff;
  };

}


#endif // XMLTAG_H