Variable.hh

Go to the documentation of this file.

#ifndef __DIADES__ALTARICA__VARIABLE__HH
#define __DIADES__ALTARICA__VARIABLE__HH

#include<diades/utils/Exceptions.hh>
#include<diades/altarica/Value.hh>
#include<diades/altarica/VariableDecl.hh>
using namespace std;

namespace Diades
{

  namespace Altarica
  {
        class FlatVariableIterator;


        
        class Variable
        {
        public:
          
          typedef Utils::Exception<Variable> Exception;
          static string typeName() { return "Diades::Altarica::Variable"; }
          
        public:
          typedef FlatVariableIterator FlatIterator;
          typedef Variable * Pointer;

          typedef reference_wrapper<Variable> Reference;

          typedef reference_wrapper<Variable const> ConstReference;


          typedef vector<Reference> VarVector;


          typedef vector<Variable>::iterator VariableIterator;
          
          typedef  vector<Variable>::const_iterator VariableConstIterator;
          
          typedef unordered_map<Identifier,VarVector::size_type> SubVarDictionary;

          
        private:

          Identifier _name;



          mutable string _fullname;
          
          VarVector _scope;

          
          vector<VariableDecl::ConstReference> _declaration;

          mutable vector<Variable> _subVariables;

         

          bool _isFree;


          vector<Value::ConstReference> _current;



          mutable SubVarDictionary _varDictionary;
          
        protected:
         
          
          Variable & initSubVariable(const Identifier & name) const;


          Variable & initSubVariable(unsigned index) const;

          void instanciateVariable() const;

         
          friend class FlatVariableIterator;

        public:
          Variable():_name(),_scope(),_declaration(),_subVariables(),_isFree(true),_current(),_varDictionary(){}
          
          
          virtual ~Variable(){ clear();  }


          Variable & getVariableFromPath(const string & varPath);



          const Variable & getVariableFromPath(const string & varPath) const;

          
          FlatIterator varBegin();

          FlatIterator varEnd();
          

          virtual void init(const Identifier & name,
                                                const VariableDecl & declaration,
                                                Variable & scope);


          virtual void clear();

          const Variable & scope() const
          {
                require(Exception,!isNull(),"scope: null variable.");
                return _scope[0];
          }




          void assign(const Value & value);



          const Type & type() const
          {
                require(Exception,!isNull(),"type: null variable.");
                return declaration().type();
          }



          const VariableDecl & declaration() const
          {
                require(Exception,!isNull(),"declaration: null variable.");
                return _declaration[0];
          }






          const Identifier & name() const
          {
                require(Exception,!isNull(),"name: null variable.");
                return _name;
          }


          const string & fullname() const;
          

          bool isNull() const
          {
                return _declaration.empty();
          }

          bool isFree() const
          {
                return _isFree;
          }



          void makeFree();


          bool operator==(const Variable & variable) const
          {
                return this == &variable;
          }


          bool operator!=(const Variable & variable) const
          {
                return !( (*this)==variable);
          }
          
         

          Variable & getVariable(const Identifier & name);

          const Variable & getVariable(const Identifier & name) const;

          Variable & getVariable(unsigned index);

          const Variable & getVariable(unsigned index) const;

          

          VariableIterator variableBegin();
          VariableIterator variableEnd();


          VariableConstIterator variableBegin() const;
          VariableConstIterator variableEnd() const;


          const Value & value() const;


          
        };




        
        class FlatVariableIterator
        {
        public:

          typedef FlatVariableIterator   self;
          typedef ptrdiff_t            difference_type;
          typedef std::forward_iterator_tag    iterator_category;
          typedef VariableDecl  value_type;
          typedef Variable*  pointer;
          typedef Variable&  reference;

        private:

          Variable * _owner;
          unsigned _index;
          Variable::SubVarDictionary::const_iterator _fieldIt;
          FlatVariableIterator * _iterator;

        public:
          
          FlatVariableIterator() : _owner(nullptr),_index(0),_iterator(0){}

          FlatVariableIterator(const FlatVariableIterator & it);

          FlatVariableIterator & operator=(const FlatVariableIterator & it);
          
                
          explicit FlatVariableIterator( Variable & owner, unsigned index);
          explicit FlatVariableIterator( Variable & owner, const Variable::SubVarDictionary::const_iterator & fieldIt);
          ~FlatVariableIterator();
          reference operator*() const;

          pointer operator->() const;
          
          self & operator++();

          self operator++(int);

          bool operator==(const self & it) const;

          bool operator !=(const self & it) const;

        };




  };

};
#endif