PData.h

Go to the documentation of this file.

#ifndef PDATA_H
#define PDATA_H

#include <pthread.h>
#include <unistd.h>
#include <sstream>

enum {PTYPE_NULL = 1, PTYPE_INT = 2, PTYPE_FLOAT = 4, PTYPE_STRING = 8, PTYPE_LIST = 16, PTYPE_MAP = 32};


#include "PDataNull.h"
#include "PDataInt.h"
#include "PDataFloat.h"
#include "PDataString.h"
#include "PDataList.h"
#include "PDataMap.h"

using namespace std;

extern void PDataGrammarCallParser(char* evalstring);
extern int yyparse();

class PData {
  
public:




  PData(PData* owner = NULL);
  ~PData();






  PData(int v, PData* owner = NULL);
  PData(long v, PData* owner = NULL);
  PData(float v, PData* owner = NULL);
  PData(double v, PData* owner = NULL);
  PData(string v, PData* owner = NULL);





  PData(const PData& v, PData* owner = NULL);



  PData(const char* command, const char* evalstring, int len=-1);
  PData(const char* command, string evalstring);
  PData(string command, string evalstring);



  int operator=(int v);
  long operator=(long v);
  float operator=(float v);
  double operator=(double v);
  string operator=(string v);
  PData& operator=(PData& v) { v._checkParsed(); delete _datum; _datum = _makeNewDatum(v._datum); _setDirty(); return v; }
  int set(int v) {return operator=(v);}
  long set(long v) {return operator=(v);}
  float set(float v) {return operator=(v);}
  double set(double v) {return operator=(v);}
  string set(string v) {return operator=(v);}
  PData& set(PData& v) {return operator=(v);}





  PData& eval(string evalstring);
  
  PData& eval(const char* evalstring, int len=-1);

  PData& init(string typestring);
  PData& init(const char* typestring, int len=-1);

  PData& raw(string rawbytes);
  PData& raw(const char* rawbytes, int len=-1);



  operator int() {_checkParsed(); return (int)(*_datum);}
  operator long() {_checkParsed(); return (long)(*_datum);}
  operator float() {_checkParsed(); return (float)(*_datum);}
  operator double() {_checkParsed(); return (double)(*_datum);}
  operator string() {_checkParsed(); return (string)(*_datum);}
  int getInt() {_checkParsed(); return (int)(*_datum);}
  long getLong() {_checkParsed(); return (long)(*_datum);}
  float getFloat() {_checkParsed(); return (float)(*_datum);}
  double getDouble() {_checkParsed(); return (double)(*_datum);}
  string getString() {_checkParsed(); return (string)(*_datum);}



  PData& operator[](string index) {_checkParsed(); return *((*_datum)[index]);}
  PData& operator[](const char* index) {_checkParsed(); return *((*_datum)[index]);}
  PData& operator[](int index) {_checkParsed(); return *((*_datum)[index]);}
  PData& get(string index) {return operator[](index);}
  PData& get(const char* index) {return operator[](index);}
  PData& get(int index) {return operator[](index);}
  


  void clear() {_checkParsed(); _datum->clear(); _setDirty();}
  void setNull() {delete _datum; _datum = new PDataNull(this); _setDirty();}
  void append(const PData& v) {const_cast<PData&>(v)._checkParsed(); _checkParsed(); _datum->append(v); _setDirty();}
  void erase(int index) {_checkParsed(); _datum->erase(index); _setDirty();}
  void erase(string index) {_checkParsed(); _datum->erase(index); _setDirty();}
  void erase(const char* index) {_checkParsed(); _datum->erase(index); _setDirty();}
  void resize(int size) {_checkParsed(); _datum->resize(size); _setDirty();}
  


  string getType() {_checkParsed(); return _datum->getType();}
  int getTypeEnum() {_checkParsed(); return _datum->getTypeEnum();}
  int size() {_checkParsed(); return _datum->size();}
  int isRaw() {return _is_raw;}
  long getIndex() { return _index; }
  int has(const PData& v) {const_cast<PData&>(v)._checkParsed(); _checkParsed(); return _datum->has(v);} // list and map inclusion check
  int hasKey(const char* v) {_checkParsed(); return _datum->hasKey(v);}
  vector<string> keys() {_checkParsed(); return _datum->keys();}
  void iterateKeys() {_checkParsed(); _datum->iterateKeys();}
  int hasNextKey() {_checkParsed(); return _datum->hasNextKey();}
  string getNextKey() {_checkParsed(); return _datum->getNextKey();}
  
  int operator==(const PData& v) {return equals(v);}
  int equals(const PData& v) {return (const_cast<PData&>(v).toString() == toString());}
  int find(const PData& v) {const_cast<PData&>(v)._checkParsed(); _checkParsed(); return _datum->find(v);}



  friend ostream& operator<<(ostream& o, PData& p) { o << p.toString(); return o; }
  string toString() { _updateStringCache(); return string(_string_cache); }
  
  void exportBuffer(void (*receiveCallback)(const char* buffer, int size));
  
  char* insertTransmit(char* buf_start, char* buf_end);

  int getTransmitSize();

  static string& quoteString(string& s);

  static string& unquoteString(string& s);

private:
  // static parser functions and stuff declared here, the static parser must
  // access them, but they shouldn't be called by anything else.
  static void ParserStartMap();
  static void ParserMapKey(char* label);
  static void ParserMapInsert();
  static void ParserEndMap();
  static void ParserStartList();
  static void ParserListInsert();
  static void ParserEndList();
  friend void PDataGrammarCallParser(char* evalstring);
  friend int yyparse();
  friend int yylex();

private:
  static pthread_mutex_t _ParserLock; 
  pthread_mutex_t _buffer_lock; 
  long _index; 
  PData* _owner; 
  PDataNull* _datum; 
  int _is_dirty; 
  int _is_raw; 
  char* _string_cache; 
  int _string_cache_bufsize; 
  int _string_cache_strsize; 
  int _is_cached_parse; 
  enum {INIT_STRING_CACHE_SIZE = 50};

  void _init(PData* owner); 
  void paramConstructor(const char* command, const char* evalstring, int len=-1);
  void _parserWrapper(); 
  void _checkParsed(); 
  PDataNull* _makeNewDatum(PDataNull* pdn); 
  void _updateStringCache(); 
  void _forceStringCache(); 
  void _resizeStringCache(int size); 
  void _setStringCache(const char* evalstring, int len); 
  void _setDirty(); 
  void _deleteDatum() {delete _datum;} 
  void _replaceDatum(PDataNull* pdn) {_deleteDatum(); _datum = pdn;} 

  // static parser-related helper fields:
  static PData* _parser_target; 

};

#endif