PropertyFacility.hpp

Go to the documentation of this file.

// vim:sw=2:ts=8
#ifndef PROPERTIES__HPP
#define PROPERTIES__HPP

#include <string>
#include <iterator>

#include "def_graph.hpp"
#include "GraphException.hpp"
#include "Property.hpp"



namespace gns {


  class PropertyFacility
  {
    public:
      typedef std::map<std::string, AbstractProperty*> PropertyMap;
      typedef std::hash_map<std::string, std::pair<int, PropertyMap*> > Map;

    private:
      Map *_m;

      int users;


    public:
      PropertyFacility();
      PropertyFacility(const PropertyFacility &p);

      ~PropertyFacility();

      void register_user();

      void unregister_user();

      int user_count();

      void add_id(std::string id);

      void del_id(std::string id);

      template <class T>
        void set(std::string id, std::string pname, T val);

      template <class T>
        T get(std::string id, std::string pname);

      bool isset(std::string id, std::string pname);

      void unset(std::string id, std::string pname);

      void clone(std::string id1, std::string id2, PropertyFacility* prop2 = NULL);


      typedef PropertyMap::iterator PropertyIterator;
 
      PropertyIterator begin(std::string id);
      PropertyIterator end(std::string id);
  };


  template <class T>
    void PropertyFacility::set(std::string id, std::string pname, T val)
    {
      Map::iterator it = _m->find(id);
      if( it == _m->end() )
        throw GraphExMsg(invalid_id, std::string("ID: ")+id);

      PropertyMap *map = (*it).second.second;
      PropertyMap::iterator itmap = map->find(pname);
      if( itmap == map->end() )
      {
        // Create new property and insert it
        Property<T> *newp = new Property<T>(val);
        AbstractProperty *newap = dynamic_cast<AbstractProperty*>(newp);
        map->insert(std::make_pair(pname, newap));
      }
      else
      {
        // Chance value of already existing property
        AbstractProperty *ap = (*itmap).second;

        if( typeid(T).name() != ap->get_type() )
          throw GraphExMsg(invalid_property_type, typeid(T).name() + std::string(" != ") + ap->get_type() );
        Property<T> *prop =  static_cast<Property<T>*>(ap);
        // 2.check: makes sense ?
        if( typeid(T) != typeid(prop->val) )
          throw GraphExMsg(invalid_property_type, std::string("The actual typeid's differ ! ") );

        /*
        Property<T> *prop = dynamic_cast<Property<T>*>(ap);
        if( prop == NULL )
          throw GraphEx(invalid_property_type);
        */
        prop->val = val;
      }
    };


  template <class T>
    T PropertyFacility::get(std::string id, std::string pname)
    {
      // Find node property map
      Map::iterator it = _m->find(id);
      if( it == _m->end() )
        throw GraphExMsg(invalid_id, std::string("ID: ") + id);

      PropertyMap *map = (*it).second.second;

      // Find property
      PropertyMap::iterator itmap = map->find(pname);
      if( itmap == map->end() )
        throw GraphEx(invalid_property);

      // Get property
      AbstractProperty *ap = (*itmap).second;

      if( typeid(T).name() != ap->get_type() )
        throw GraphExMsg(invalid_property_type, typeid(T).name() + std::string(" != ") + ap->get_type() );
      Property<T> *prop = static_cast<Property<T>*>(ap);
      // 2.check
      if( typeid(T) != typeid(prop->val) )
        throw GraphExMsg(invalid_property_type, std::string("The actual typeid's differ ! ") );

      /*
      Property<T> *prop = dynamic_cast<Property<T>*>(ap);
      if( prop == NULL )
        throw GraphEx(invalid_property_type);
       */
      return prop->val;
    };


}

#endif

---