Domains.hh

Go to the documentation of this file.

#ifndef __DIADES__ALTARICA__DOMAINS__HH
#define __DIADES__ALTARICA__DOMAINS__HH

#include<iostream>
#include<map>
#include"Type.hh"
#include"Value.hh"

namespace Diades
{
  namespace Altarica
  {

        class RangeDomain;
        class EnumerationDomain;
        class BooleanDomain;
        class IntegerDomain;
        class StructureDomain;
        class ArrayDomain;
        class NodeDecl;
        
        class DomainIterator
        {
          
        public:
          typedef DomainIterator   self;
          typedef ptrdiff_t        difference_type;
          typedef std::forward_iterator_tag    iterator_category;
          typedef Value   value_type;
          typedef const Value*  pointer;
          typedef const Value&  reference;
          static self nullIterator;
        private:
          typedef enum{NotADomain,Range,Enumeration,Integers,Booleans, Structure,Array} DomainType;
          DomainType _type;
          union 
          {
                const RangeDomain * _range;
                const EnumerationDomain * _enumeration;
                const BooleanDomain * _booleans;
                const IntegerDomain * _integers;
                const StructureDomain * _structure;
                const ArrayDomain * _array;
          } _domainData;
          vector<Value::ConstReference> _current; // tricky I know but so useful
          ValueEnumeration::const_iterator _itSet;
          union
          {
                vector<DomainIterator> * _array;
                map<Identifier, DomainIterator> * _structure;
          } _dataIt;
          union
          {
                vector<DomainIterator> * _array;
                map<Identifier, DomainIterator> * _structure;
          } _endIt;
          union
          {
                vector<DomainIterator> * _array;
                map<Identifier, DomainIterator> * _structure;
          } _beginIt;   
          int _index;

          void goNext();
          void updateCurrentArray();
          void updateCurrentStructure();
          void copy(const DomainIterator & it);
          
        public:

          DomainIterator():_type(NotADomain), _current(), _itSet(), _index(0){}

          
          DomainIterator(const RangeDomain & range, const Value & value):_type(Range),_current(),_itSet(),_index(0)
          {
                _current.push_back(value);
                _domainData._range = &range;
          }
          
          DomainIterator(const EnumerationDomain & enumeration,
                                         const ValueEnumeration::const_iterator & itSet):_type(Enumeration),
                                                                                                                                         _current(), _itSet(itSet),_index(0)
          {
                _domainData._enumeration = &enumeration;
          }
         
          DomainIterator(const BooleanDomain & booleans, int index): _type(Booleans),
                                                                                                                                 _current(),
                                                                                                                                 _itSet(),_index(index)
          {
                _domainData._booleans = &booleans;
          }

          DomainIterator(const IntegerDomain & integers, int index): _type(Integers),
                                                                                                                                        _current(),_itSet(),_index(index)
          {
                _domainData._integers = &integers;
          }


          DomainIterator(const StructureDomain & structure,
                                         const map<Identifier, DomainIterator> & dataIt,
                                         const map<Identifier, DomainIterator> & beginIt,
                                         const map<Identifier, DomainIterator> & endIt);
        
        
          DomainIterator(const ArrayDomain & array,
                                         const vector<DomainIterator> & vectIt,
                                         const vector<DomainIterator> & beginIt,
                                         const vector<DomainIterator> & endIt);

         
          DomainIterator(const DomainIterator & it):_type(NotADomain) { copy(it); }


          ~DomainIterator();
          void clear();
          
          DomainIterator & operator=(const DomainIterator & it)
          {
                if(this != &it)
                  {
                        copy(it);
                  }
                return *this;
          }

          
          reference operator*() const;
          pointer operator->() const;
          self & operator++()
          {
                goNext();
                return *this;
          }
          self  operator++(int)
          {
                self tmp = *this;
                goNext();
                return tmp;
          }
          bool operator==(const self & it) const;
          bool operator!=(const self & it) const
          {
                return !(*this == it);
          }       
        };













        
        class DomainFactory;
        
        class Domain
        {
        public:
          typedef reference_wrapper<Domain> Reference;
          typedef reference_wrapper<Domain const> ConstReference;
          typedef Domain * Pointer;
          typedef const Domain * ConstPointer;
          typedef enum {InvalidDomain, Simple, Arrayed, Structured} Category;


          typedef enum{NotADomain,Range,Enumeration,Integers,Booleans, Structure,Array} DomainType;


          typedef map<Identifier,ConstReference> StructureFields;

          typedef DomainIterator Iterator;
          
        protected:
          DomainFactory & _factory;
          Identifier _name;
          
        protected:
          unsigned _id;
          Type::ConstReference _type;
          Category _category;
          mutable set<Identifier> _otherNames;

          
          void setId(unsigned id)
          {
                _id = id;
          }


        protected:
          
          Domain(const Identifier & name,DomainFactory & factory);
          

          friend class DomainFactory;
          
        public:   
          unsigned id() const
          {
                return _id;
          }


          virtual string printDomain() const = 0;


        protected:
          void setName(const Identifier & name)
          {
                _name = name;
          }

                  
          void setOtherName(const Identifier & name) const
          {
                _otherNames.insert(name);
          }

        public:
          const Identifier & name() const
          {
                return _name;
          }

          set<Identifier>::const_iterator otherNameBegin() const
          {
                return _otherNames.begin();
          }
  
          set<Identifier>::const_iterator otherNameEnd() const
          {
                return _otherNames.end();
          }
          
          virtual ~Domain() {}

          virtual bool isFinite() const = 0;
          virtual unsigned cardinality() const = 0;
          virtual bool contains(const Value & value) const = 0;
          virtual DomainIterator begin() const = 0;
          virtual DomainIterator end() const = 0;

          virtual DomainIterator find(const Value & value) const = 0;

          virtual DomainType domainType() const = 0;

          Category category() const { return _category; }

          virtual const Value & defaultValue() const = 0;

          const Type & type() const { return _type; }


          const AltaricaModel & owner() const;

          AltaricaModel & owner();
          
          bool operator<(const Domain & domain) const;

          bool operator==(const Domain & domain) const
          {
                return this == &domain;
          }
          bool operator!=(const Domain & domain) const
          {
                return !(*this == domain);
          }


          bool isNull() const;
        };

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

        class RangeDomain: public Domain
        {
        private:
          Value::ConstReference  _min;
          Value::ConstReference  _max;

        
          RangeDomain(const Identifier & name,
                                  const Value & min,
                                  const Value & max,
                                  unsigned id,
                                  DomainFactory & factory);

          friend class DomainFactory;

        public:
          virtual ~RangeDomain() {}
          virtual bool isFinite() const { return true; }
          virtual unsigned cardinality() const { return _max.get().integer() - _min.get().integer() + 1; }
          virtual bool contains(const Value & value) const { return (_min.get()<=value) && (value<=_max.get()); }
          virtual DomainType domainType() const { return Range; }
          virtual DomainIterator begin() const
          {
                return DomainIterator(*this,_min);
          }
          virtual DomainIterator end() const;


          virtual DomainIterator find(const Value & value) const
          {
                if(value.type().isInteger() && (value <= _max.get()) && (value >= _min.get()))
                  {
                        return DomainIterator(*this,value);
                  }
                return end();
          }


          
          virtual string printDomain() const;

          
          bool operator<(const RangeDomain & domain) const
          {
                bool result = cardinality() < domain.cardinality();
                if(!result && (cardinality() == domain.cardinality()))
                  {
                        result =  _min.get() < domain._min.get();
                  }
                if(!result && (_min.get() == domain._min.get()))
                  {
                        result = name() < domain.name();
                  }
                return result;
          }
                
          const Value & defaultValue() const { return _min; }

          const Value & min() const { return _min; }
          const Value & max() const { return _max; }
          
        
        };


        /****************************************************************************/
        
        
        
        
        class EnumerationDomain: public Domain
        {
        private:
          ValueEnumeration _symbolSet;

        public:
          EnumerationDomain(const Identifier & name,
                                                const ValueEnumeration & valueSet,
                                                unsigned id,
                                                DomainFactory & factory);
          virtual ~EnumerationDomain() {}
          virtual bool isFinite() const { return true; }
          virtual unsigned cardinality() const {
                return _symbolSet.size(); }
          virtual bool contains(const Value & value) const;
          virtual DomainType domainType() const { return Enumeration; }
          virtual DomainIterator begin() const
          {
                return DomainIterator(*this,_symbolSet.begin());
          }
          virtual DomainIterator end() const
          {
                return DomainIterator(*this,_symbolSet.end());
          }
          virtual  DomainIterator find(const Value & value) const;
          virtual string printDomain() const; 
          const  Value & defaultValue() const { return _symbolSet[0]; }
          friend class DomainFactory;
        };

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

        class BooleanDomain: public Domain
        {
        private:
          Value::ConstReference _isTrue;
          Value::ConstReference _isFalse;
        public:
          BooleanDomain(DomainFactory & factory);
          virtual ~BooleanDomain() {}
          virtual bool isFinite() const { return true; }
          virtual unsigned cardinality() const { return 2; }
          virtual DomainType domainType() const { return Booleans; }
          virtual bool contains(const Value & value) const;
          virtual DomainIterator begin() const
          {
                return DomainIterator(*this,0);
          }
          virtual DomainIterator end() const
          {
                return DomainIterator(*this,2);
          }
          virtual  DomainIterator find(const Value & value) const
          {
                if(value.type().isBoolean())
                  {
                        if(value.boolean())
                          {
                                return DomainIterator(*this,1);
                          }
                        else
                          {
                                return DomainIterator(*this,0);
                          }
                  }
                return end();
          }
          virtual string printDomain() const;
          const Value & defaultValue() const { return _isFalse; }

          friend class DomainIterator;
        };


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

        class IntegerDomain: public Domain
        { 
        public:
          IntegerDomain(DomainFactory & factory);
          virtual ~IntegerDomain() {}     
          bool isFinite() const { return  false; }
          virtual unsigned cardinality() const { return numeric_limits<unsigned>::infinity(); }
          bool contains(const Value & value) const;
          virtual DomainType domainType() const { return Integers; }

          DomainIterator begin() const
          {
                return DomainIterator(*this,-numeric_limits<int>::infinity());
          }

          DomainIterator end() const
          {
                return DomainIterator(*this,numeric_limits<int>::infinity());
          }
          virtual  DomainIterator find(const Value & value) const
          {
                if(value.type().isInteger())
                  {
                        return DomainIterator(*this,value.integer());
                  }
                return end();
          }
                
          const Value & defaultValue() const;

          virtual string printDomain() const;    
        };



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

        
        class StructureDomain: public Domain
        {
        private:
          StructureFields _structure;
          map<Identifier, DomainIterator> _begin;
          map<Identifier, DomainIterator> _end;
          void generateStructuredBeginAndEnd(map<Identifier, DomainIterator> & begin,
                                                                                 map<Identifier, DomainIterator> & end);

        public:
          typedef StructureFields::const_iterator StructureFieldIterator;


          StructureFieldIterator fieldBegin() const
          {
                return _structure.begin();
          }
          StructureFieldIterator fieldEnd() const
          {
                return _structure.end();
          }



          
          StructureDomain(const Identifier & name,
                                          const StructureFields & structure,
                                          unsigned id,
                                          DomainFactory & factory):Domain(name,factory),
                                                                                           _structure(structure),_begin(),_end() 
          {
                _id = id;
                generateStructuredBeginAndEnd(_begin,_end);
                _category = Structured;
      
          }
          virtual ~StructureDomain() {}
          virtual bool isFinite() const;
          virtual unsigned cardinality() const;
          virtual bool contains(const Value & value) const;
          virtual DomainType domainType() const { return Structure; }
          virtual DomainIterator begin() const
          {
                return DomainIterator(*this,_begin,_begin,_end);
          }
          virtual DomainIterator end() const
          {
                return DomainIterator(*this,_end,_begin,_end);
          }
          virtual  DomainIterator find(const Value & value) const;
          
          virtual string printDomain() const;    
          const Value & defaultValue() const;
          friend class VariableDeclFactory;
          friend class DomainFactory;
        };


        
        /****************************************************************************/
        
        class ArrayDomain: public Domain
        {
        private:
          vector<Domain::ConstReference> _array;
          vector<DomainIterator> _begin;
          vector<DomainIterator> _end;


        public:
          ArrayDomain(const Identifier & name, const Domain & domain, unsigned size,unsigned id,DomainFactory & factory);
          virtual ~ArrayDomain() {}
          virtual bool isFinite() const;
          virtual unsigned cardinality() const;
          virtual bool contains(const Value & value) const;
          virtual DomainType domainType() const { return Array; }
          virtual DomainIterator begin() const
          {
                return DomainIterator(*this,_begin,_begin,_end);
          }
          virtual DomainIterator end() const
          {
                return DomainIterator(*this,_end,_begin,_end);
          }
          unsigned arraySize() const { return _array.size(); }
          const Domain & itemDomain() const { return _array[0]; }
          virtual  DomainIterator find(const Value & value) const;

          virtual string printDomain() const;   
          const Value & defaultValue() const;
          bool operator<(const ArrayDomain & domain) const
          {
                bool result = _array.size() < domain._array.size();
                if(!result && (_array.size()  == domain._array.size()))
                  {
                        if( _array.size() > 0)
                          {
                                result = (_array[0].get()) < (domain._array[0].get());
                                if(!result && ( (_array[0].get()) == (domain._array[0].get())))
                                  {
                                        result = name() < domain.name();
                                  }
                          }
                  }
                return result;
          }

          friend class VariableDeclFactory;
          friend class DomainFactory;
        };


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

        class NullDomain: public Domain
        {       
          
        public:
          NullDomain(DomainFactory & factory):Domain("__diades__altarica__null__domain",factory){}
          virtual ~NullDomain() {}
          virtual bool isFinite() const { return true; }
          virtual unsigned cardinality() const { return 0; }
          virtual bool contains(const Value & value) const { return false; }
          virtual DomainType domainType() const { return NotADomain; }
          virtual DomainIterator begin() const
          {
                return DomainIterator();
          }
          virtual DomainIterator end() const
          {
                return DomainIterator();
          }
          virtual  DomainIterator find(const Value & value) const { return end(); }

          virtual string printDomain() const { return name().str(); }   
          const Value & defaultValue() const;
          bool operator<(const Domain & domain) const
          {
                return !domain.isNull();
          }

          friend class DomainFactory;
        };





        

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

        private:
          AltaricaModel & _owner;
          vector< map<Identifier,Domain::ConstPointer> > _nodeDeclDomains;
          vector< map<Identifier,bool> > _referenceDomains;
          vector< Domain::Pointer > _basicDomains; //  _booleans in 0 and _integers in 1

        public:

          DomainFactory(AltaricaModel & model);


          void init();


          void clear();
          
          ~DomainFactory();
        

          const Domain & nullDomain() const { return *_basicDomains[0]; }
          
          const Domain & getBooleans() const { return *_basicDomains[1]; }

          const Domain & getIntegers() const { return *_basicDomains[2]; }


          const Domain & newDomain(const NodeDecl & nodeDecl);



          
          const Domain & newDomain(const Identifier & name, const Domain & associatedDomain, NodeDecl & nodeDecl);

 

          const Domain &  newDomain(const Identifier & name, const Value & min, const Value & max, NodeDecl & nodeDecl);


 
          const Domain & newDomain(const Identifier & name, const ValueEnumeration & enumeration, NodeDecl & nodeDecl);


          const Domain & newDomain(const Identifier & name, const Domain::StructureFields & structure, NodeDecl & nodeDecl);


           const Domain & newDomain(const Identifier & name, const Domain & domain, unsigned size, NodeDecl & nodeDecl);



         const  AltaricaModel & owner() const;
          AltaricaModel & owner();
        };
        
        
        
  };
};


#endif