Identifier.hh

Go to the documentation of this file.

#ifndef __DIADES__UTILS__IDENTIFIER__HH
#define __DIADES__UTILS__IDENTIFIER__HH

#include<string>
#include<vector>
#include<unordered_map>
#include<map>
#include<istream>
//#include"Label.hh"
#include"Assertion.hh"
#include"Exceptions.hh"


using std::string;
using std::vector;
using std::unordered_map;
using std::istream;
using std::map;

namespace Diades
{
  namespace Utils
  {


        class IdentifierFactory;

        istream & getIdentifierString(istream & is, std::string & identifier);
        

        class IdentifierData: public std::string
        {
        private:

          unsigned _id;

          double _rank;

          
        public:
          static string typeName() { return "Utils::IdentifierData"; }
          typedef Utils::Exception<IdentifierData> Exception;
         

          IdentifierData(const std::string & idLabel, unsigned id, double rank):std::string(idLabel),_id(id),_rank(rank){}



          IdentifierData(const IdentifierData & data):std::string(data),_id(data._id),_rank(data._rank){}




          
          unsigned id() const { return _id; }

          double rank() const { return _rank; }
        };



        
        class IdentifierFactory;


        class Identifier
        {
        private:
          IdentifierData * _data;


        public:
          static string typeName() { return "Utils::Identifier"; }
          typedef Utils::Exception<Identifier> Exception;
          typedef string::const_iterator ConstIterator;
          typedef string::const_reverse_iterator ConstReverseIterator;

        public:
          Identifier():_data(0){}


          Identifier(IdentifierData * data):_data(data){}


          Identifier(const char * cString);


          
          Identifier(const string & str);

          Identifier(const Identifier & identifier):_data(identifier._data){}


          bool valid() const
          {
                return _data != 0;
          }


          Identifier & operator=(const Identifier & identifier)
          {
                if(this != &identifier)
                  {
                        _data = identifier._data;
                  }
                return *this;
          }



          unsigned id() const
          {
                always_require(Exception,valid(),"id: Invalid identifier");
                return _data->id();
          }


          ConstIterator begin() const
          {
                always_require(Exception,valid(),"begin: Invalid identifier");
                return _data->begin();
          }


          double rank() const
          {
                always_require(Exception,valid(),"rank: invalid identifier");
                return _data->rank();
          }


          ConstIterator end()
          {
                always_require(Exception,valid(),"end: Invalid identifier");
                return _data->end();
          }


          ConstReverseIterator rbegin()
          {
                always_require(Exception,valid(),"rbegin: Invalid identifier");
                return _data->rbegin();
          }

          ConstReverseIterator rend()
          {
                always_require(Exception,valid(),"rend: Invalid identifier");
                return _data->rend();
          }


          size_t size() const
          {
                always_require(Exception,valid(),"size: Invalid identifier");
                return _data->size();
          }


          size_t length() const
          {
                return size();
          }

          const char & operator[](size_t pos) const
          {
                always_require(Exception,valid(),"operator[]: Invalid identifier");
                return _data->operator[](pos);
          }

          Identifier & operator+= ( const Identifier& str );



          Identifier & operator+= ( const string& str );





          Identifier & operator+= ( const char* s );





          Identifier & operator+= ( char c );







          const string & str() const
          {
                always_require(Exception,valid(),"str: Invalid identifier");
                return (*_data);
          }


          
          const char * c_str() const
          {
                always_require(Exception,valid(),"c_str: Invalid identifier");
                return _data->c_str();
          }


          bool operator== (const Identifier & identifier) const
          {
                return _data == identifier._data;
          }

          bool operator!= (const Identifier & identifier) const
          {
                return !operator==(identifier);
          }


          
          bool operator<(const Identifier & identifier) const;
          
          friend istream & operator >> (istream & is, Identifier & identifier);
          friend class IdentifierFactory;
        };


        inline std::ostream& operator << (std::ostream & os, const Identifier & identifier)
        {
          if(identifier.valid())
                {
                  return os << identifier.str();
                }
          return os << "__DIADES__UTILS__INVALID__IDENTIFIER";
        }


        class IdentifierFactory
        {
        private:
          vector<Identifier> _identifiers;
          map<double,Identifier> _rankings;
          unordered_map<string,unsigned> _dictionary;
          static IdentifierFactory * _instance;



        public:
          
          static void destroy();



        protected:
          
          IdentifierFactory():_identifiers(),_rankings(),_dictionary(){}

        public:
          static string typeName() { return "Utils::IdentifierFactory"; }
          typedef Utils::Exception<IdentifierFactory> Exception;

          ~IdentifierFactory();
        
          static IdentifierFactory * factory();

          Identifier getIdentifier(unsigned id);

          Identifier getIdentifier(const std::string & str);

        };


        
  };
};


namespace std
{
  template<> struct hash<Diades::Utils::Identifier>
  {
        size_t operator()(const Diades::Utils::Identifier & identifier) const
        {
          if(identifier.valid())
                {
                  return (size_t) (identifier.rank() * 100000);
                }
          return 0;
        }
  };
};

#endif