Variable.hh

Go to the documentation of this file.

#ifndef __DIADES__ALTARICA__VARIABLE__HH
#define __DIADES__ALTARICA__VARIABLE__HH

#include<vector>
#include "Domains.hh"
using namespace std;

namespace Diades
{

  namespace Altarica
  {

        typedef enum{NoScope,GlobalScp,NodeScp,VariableScp,FunctionScp,FirstOrderFormulaScp} VariableScope;
 

        class Variable;
        class VariableData
        {
        
 
        private:
          Identifier _label;           
          Domain _domain;              
          union
          {
                map<Identifier,Variable> * _structure;    
                vector<Variable> * _array; 
          } _fields;
          set<Identifier> _fieldName;  
          set<Identifier> _attrib;     
          void * _scope;               
          VariableScope _scopeType;    
          Value _value;                
          unsigned _id;                
          bool _isFree;                

          void createStructureVariables(const set<Identifier> & attributes, const StructureDomainData * domainData);
        
          void createArrayVariables(const set<Identifier> & attributes, const ArrayDomainData * domainData);
        

          VariableData(const Identifier & label, Domain domain,
                                   const set<Identifier> & attributes,
                                   unsigned id);

          VariableData(const Identifier & label,
                                   const set<Variable> & variables,
                                   unsigned id,
                                   Node node);

          VariableData(const Identifier & label, Domain domain,
                                   const set<Identifier> & attributes,
                                   unsigned id,
                                   Node node);


          VariableData(const Identifier & label,
                                   const set<Variable> & variables,
                                   const set<Identifier> & attributes,
                                   unsigned id,
                                   Node node);

        

          VariableData(const Identifier & label, Domain domain,
                                   const set<Identifier> & attributes,
                                   unsigned id,
                                   Variable variable);

          // /**
          //      Parmetrised constructor
          //      @param label Label of the Variable 
          //      @param domain Domain of the Variable
          //      @param fields Fields of the Variable if the Variable is a structure, empty otherwise
          //      @param attributes Attributes of the Variable empty otherwise 
          //      @param id the id of the Variable
          //      @param function The scope of the variable
          //   **/   
          // VariableData(const Identifier & label, Domain domain
          //             const vector<Identifier> & attributes,
          //             const vector<Variable> & fields,
          //             unsigned id,
          //             Function function);

          // /**
          //      Parmetrised constructor
          //      @param label Label of the Variable 
          //      @param domain Domain of the Variable
          //      @param fields Fields of the Variable if the Variable is a structure, empty otherwise
          //      @param attributes Attributes of the Variable empty otherwise
          //      @param id the id of the Variable
          //      @param formula The scope of the variable
          //   **/   
          // VariableData(const Identifier & label, Domain domain
          //             const vector<Identifier> & attributes,
          //             const vector<Variable> & fields,
          //             unsigned id,
          //             FirstOrderFormula formula);

        public:
          VariableData();

          ~VariableData();


          friend class VariableFactory;
          friend class Variable;
        };


        /*********************************************************************************/
  
        class Variable
        {
    
        public:
    
          typedef set<Identifier>::const_iterator AttributeIterator; 
          typedef set<Identifier>::const_iterator FieldNameIterator;

        private:
    
          VariableData * _data; 
    
          Variable(VariableData * data):_data(data){}
    
    
        public:
          Variable():_data(0){}

          Variable(const Variable & variable):_data(variable._data){}

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

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

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

          bool operator<(const Variable & variable) const
          {
                return _data < variable._data;
          }

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

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

          Domain domain() const
          {
                if(valid()) { return _data->_domain; } return Domain();
          }

          Type type() const { if(valid()) { return domain().type(); } return Type(); }

          bool isSimple() const
          {
                
                return valid() && domain().type().isBasic();
          }

          bool isStructure() const
          {
                return valid() && domain().type().isStructure();
          }

          bool isArray() const
          {
                return valid() && domain().type().isArray();
          }


          unsigned size() const;

          DomainCategory category() const { return domain().category(); }


          bool isFree() const;

        
          Value value() const;


          bool setValue(const Value & value);

          bool makeFree();

        
          ~Variable() { _data = 0; }

          Identifier label() const
          {
                if(!valid()) { return ""; } return _data->_label;
          }

          AttributeIterator attributeBegin() const;

          AttributeIterator attributeEnd() const;



          Variable getField(unsigned index) const;


          FieldNameIterator fieldBegin() const;
          
          FieldNameIterator fieldEnd() const;
          Variable getField(const Identifier & identifier) const;

          VariableScope scopeType() const
          {
                if(valid())
                  {
                        return _data->_scopeType;
                  }
                return NoScope;
          }


          Node nodeScope() const;

          Variable variableScope() const
          { 
                if(!valid())
                  {
                        return Variable();
                  }
                if(scopeType() != VariableScp)
                  {
                        return Variable();
                  }
                return *(static_cast<Variable *>(_data->_scope));
          }

          friend ostream & operator<<(ostream & os, const Variable & var)
          {
                return os << var.label();
          }
        
          //Function functionScope() const;
          //FirstOrderFormula firstOrderFormulaScope() const;
          friend class VariableFactory; 
          friend class VariableData;
        };


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

        class VariableFactory
        {
        private:
          unordered_map<Identifier,Variable> _modelVariableOfLabel;
          vector<Variable> _modelVariables;
          vector< unordered_map<Identifier,Variable> > _nodeVariables; 
          //vector< unordered_map<Identifier,Variable > > _funcVariables; 
          //vector< unordered_map<Identifier,Variable > > _folVariables;
          vector<Variable> _internalVariables;  
          set<Identifier> _emptyAttributes;
          set<Identifier> _emptyFields;
  
          static VariableFactory * _variableFactory;

    
          Variable newSimpleVariable(const Identifier & label,
                                                                 Domain domain, 
                                                                 const set<Identifier> & attributes);


          Variable newSimpleVariable(const Identifier & label,
                                                                 Domain domain, 
                                                                 const set<Identifier> & attributes,
                                                                 Node node);

          Variable newSimpleVariable(const Identifier & label,
                                                                 Domain domain, 
                                                                 const set<Identifier> & attributes,
                                                                 Variable variable);

          Variable newStructureVariable(const Identifier & label,
                                                                        Domain domain, 
                                                                        const set<Identifier> & attributes);
        

          Variable newStructureVariable(const Identifier & label,
                                                                        const set<Variable> & variables, Node node);
        

          Variable newStructureVariable(const Identifier & label,
                                                                        Domain domain, 
                                                                        const set<Identifier> & attributes,
                                                                        Node node);

          Variable newStructureVariable(const Identifier & label,
                                                                        Domain domain, 
                                                                        const set<Identifier> & attributes,
                                                                        Variable variable);

          Variable newArrayVariable(const Identifier & label,
                                                                Domain domain, 
                                                                const set<Identifier> & attributes);

          Variable newArrayVariable(const Identifier & label,
                                                                Domain domain, 
                                                                const set<Identifier> & attributes,
                                                                Node node); 
          Variable newArrayVariable(const Identifier & label,
                                                                Domain domain, 
                                                                const set<Identifier> & attributes,
                                                                Variable variable);
        public:
          VariableFactory();


          ~VariableFactory();

          static VariableFactory * factory(); 


          
          const set<Identifier> & emptyAttributes() const
          {
                return _emptyAttributes;
          }


          
          const set<Identifier> & emptyFields() const
          {
                return _emptyAttributes;
          }

          

          Variable newVariable(const Identifier & label, Domain domain, 
                                                   const set<Identifier> & attributes);

          Variable newVariable(const Identifier & label, Domain domain, 
                                                   const set<Identifier> & attributes,
                                                   Node node);



          Variable newVariable(const Identifier & label, const set<Variable> & variables,
                                                   Node node);





          Variable newVariable(const Identifier & label, Domain domain, 
                                                   const set<Identifier> & attributes,
                                                   Variable variable);
        };


        
        Variable newVariable(const Identifier & label, Domain domain, 
                                                 const set<Identifier> & attributes);

        Variable newVariable(const Identifier & label, Domain domain, 
                                                 const set<Identifier> & attributes,
                                                 Node node);



        Variable newVariable(const Identifier & label, const set<Variable> & variables,
                                                 Node node);





        Variable newVariable(const Identifier & label, Domain domain, 
                                                 const set<Identifier> & attributes,
                                                 Variable variable);

        


        
  };


};
#endif