typeNode.h

Ir a la documentación de este archivo.

//typeNode.h
//-------------------------------------------------------------------------------------------
/*
 * Fco. Javier Bohórquez Ogalla
 * 75766599-E
 * Puerto Real (Cádiz)
 * powersgame@gmail.com
 */
//-------------------------------------------------------------------------------------------
/*
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
 * MA 02110-1301, USA.
 */
//-------------------------------------------------------------------------------------------
#ifndef _RUN_TREE_TYPENODE_
#define _RUN_TREE_TYPENODE_

//-------------------------------------------------------------------------------------------

#include <string>
#include <vector>
#include <map>
#include <iostream>
#include <sstream>
#include <stdlib.h>
#include <sstream>
#include <boost/regex.hpp>

#include "../table/classNode.h"
#include "expNode.h"

using namespace std;
using namespace boost;

//-------------------------------------------------------------------------------------------

class boolNode :
   public logicNode {
 public:
   boolNode (bool data);
   boolNode (boolNode* data);
   void run ();
};

//-------------------------------------------------------------------------------------------

class boolConstNode : public boolNode {
   public:
      boolConstNode (bool data);
      void rmRef();
};

//-------------------------------------------------------------------------------------------

class numNode :
   public arithNode {
 public:
   numNode (num data);
   numNode (string data);
   numNode (numNode* data);
   void run ();
};

//-------------------------------------------------------------------------------------------

class numConstNode : public numNode {
   public:
      numConstNode (num data);
      void rmRef();
};

//-------------------------------------------------------------------------------------------

class strNode :
   public stringNode {
 public:
   strNode (string data);
   strNode (strNode* data);
   strNode (runNode* data);
   strNode (runNode* data, bool id );
   void run ();
   bool is_string () const;
};

//-------------------------------------------------------------------------------------------

class strConstNode : public strNode {
   public:
      strConstNode (string data);
      void rmRef();
};

//-------------------------------------------------------------------------------------------

class nullNode :
   public dexpNode {
 public:
   nullNode ();
   void run ();
   string print () const;
};

//-------------------------------------------------------------------------------------------

class listNode :
   public runNode {
 public:
   listNode (runNode* ele1, runNode* ele2 = NULL);
   void run ();
   int size ();
   vector<runNode*> listvalue () const;
   bool isAsigList ();
   listNode* quitAsig ();
    bool is_runlist () const;
 private:
   runNode* ele1_, *ele2_;
   vector<runNode*> list_;
   bool exec_;
};

//-------------------------------------------------------------------------------------------

class mapNode :
   public runNode {
 public:
   mapNode (runNode* key, runNode* value);
   void run ();
   runNode* key () const;
   runNode* value () const;
 private:
   runNode *key_, *value_;
};

//-------------------------------------------------------------------------------------------

class arrayNode :
   public dexpNode {
 public:
   arrayNode (listNode* list);
   arrayNode ();
   arrayNode (arrayNode* array);
   arrayNode (arrayNode* array, refNode* &refSearch);
   void run ();
   string print () const;
   symbols* getArray ();
   void insert (runNode* key, runNode* val, bool str = false);
   void del (runNode* key, bool str = false, bool force_position = false );
   runNode *get (runNode* key, bool str = false);
   int size () const;
   bool compare (runNode* node, int op = 0);
   int getCount () const;
   void cAll (runNode* node_search, runNode* node_new);
   bool isref (runNode* node);
   void clear ();
   void clearRef ();
   void setArray (symbols array);
   void push (runNode* node);
   virtual runNode * copyArray (arrayNode * a);
   runNode * getClass ();
   static void generateClass  ();
   bool boolvalue () const;
   num numvalue () const;
   string strvalue () const;
   ~arrayNode ();
#if JSON==1 
   void toJsonSymbols ();
#endif
 protected:
   string printLevel (short int level) const;
   void fromList (listNode * l, bool addref = false);
   static runNode *copy(arrayNode *a, arrayNode *b);
   static classNode *class_;
   bool asociative_;
   symbols array_;
};

//-------------------------------------------------------------------------------------------

class arrayConstNode : public arrayNode {
   public:
      arrayConstNode (listNode* list);
      void run ();
      void rmRef();
      inline void isCloned (bool cloned) {cloned_ = cloned;}
   private:
      listNode* list_;
      bool cloned_;
};

//-------------------------------------------------------------------------------------------

class objectNode : public arrayNode {
 public:
   objectNode (classNode * c = NULL);
   objectNode (symbols* s, classNode * c = NULL);
   objectNode (listNode* l, classNode * c = NULL);
   objectNode (arrayNode* a);
   objectNode (objectNode* a);
   runNode * getClass ();
   string print () const ;
 private:
   classNode * class_;
};

//-------------------------------------------------------------------------------------------

class regexpNode:
   public dexpNode {
 public:
   regexpNode (string str);
   regexpNode (regexpNode* r);
   regex exvalue () const;
   void run ();
   string strvalue () const;
   bool boolvalue () const;
   num numvalue () const;
   string print () const;
 private:
   string str_;
   regex ex_;
};

//-------------------------------------------------------------------------------------------

class regexpConstNode : public regexpNode {
   public:
   void rmRef();
};

//-------------------------------------------------------------------------------------------

template <typename T>
runNode *create(listNode* list) {
  return new T(list);
}

#endif
//-------------------------------------------------------------------------------------------
//Fco. Javier Bohórquez Ogalla