src/loader/ParsedSource.h

   1 /*
   2  * ParsedSource.h
   3  *
   4  *  Created on: Aug 26, 2012
   5  *      Author: holy
   6  */
   7
   8 #ifndef LOADER_PARSEDSOURCE_H_
   9 #define LOADER_PARSEDSOURCE_H_
  10
  11 #include <iosfwd>
  12 #include <map>
  13 #include <set>
  14 #include <string>
  15 #include <vector>
  16
  17 namespace loader {
  18
  19 class PropertyList;
  20 class Value;
  21
  22 class Literal {
  23
  24 public:
  25         enum Type {
  26                 ARRAY_VALUES,
  27                 ARRAY_PROPS,
  28                 BOOLEAN,
  29                 COLOR,
  30                 NUMBER,
  31                 STRING,
  32                 VECTOR,
  33                 OBJECT
  34         };
  35
  36 public:
  37         explicit Literal(const std::vector<Value *> &);
  38         explicit Literal(const std::vector<PropertyList *> &);
  39         explicit Literal(bool);
  40         Literal(int r, int g, int b, int a = 255);
  41         explicit Literal(int number);
  42         Literal(const std::string &);
  43         Literal(int x, int y);
  44         Literal(const std::string &typeName, PropertyList *properties);
  45         ~Literal();
  46 private:
  47         Literal(const Literal &);
  48         Literal &operator =(const Literal &);
  49
  50 public:
  51         Type GetType() const { return type; }
  52
  53         const std::vector<Value *> &GetValues() const;
  54         const std::vector<PropertyList *> &GetPropertyLists() const;
  55         bool GetBoolean() const;
  56         int GetRed() const;
  57         int GetGreen() const;
  58         int GetBlue() const;
  59         int GetAlpha() const;
  60         int GetNumber() const;
  61         const std::string &GetString() const;
  62         int GetX() const;
  63         int GetY() const;
  64         const std::string &GetTypeName() const;
  65         const PropertyList *GetProperties() const;
  66
  67 private:
  68         PropertyList *props;
  69         std::string str;
  70         std::vector<Value *> values;
  71         std::vector<PropertyList *> propertyLists;
  72         int i1, i2, i3, i4;
  73         bool b;
  74         Type type;
  75
  76 };
  77
  78
  79 class Value {
  80
  81 public:
  82         explicit Value(const std::string &identifier)
  83         : literal(0), identifier(identifier), isLiteral(false) { }
  84         explicit Value(Literal *literal)
  85         : literal(literal), isLiteral(true) { }
  86         ~Value();
  87 private:
  88         Value(const Value &);
  89         Value &operator =(const Value &);
  90
  91 public:
  92         bool IsLiteral() const { return isLiteral; }
  93         const Literal &GetLiteral() const;
  94         const std::string &GetIdentifier() const;
  95
  96 private:
  97         Literal *literal;
  98         std::string identifier;
  99         bool isLiteral;
 100
 101 };
 102
 103
 104 class PropertyList {
 105
 106 public:
 107         PropertyList() { }
 108         ~PropertyList();
 109 private:
 110         PropertyList(const PropertyList &);
 111         PropertyList &operator =(const PropertyList &);
 112
 113 public:
 114         void SetProperty(const std::string &name, Value *value) {
 115                 props[name] = value;
 116         }
 117
 118         typedef std::map<std::string, Value *>::iterator Iterator;
 119         typedef std::map<std::string, Value *>::const_iterator ConstIterator;
 120         Iterator Begin() { return props.begin(); }
 121         ConstIterator Begin() const { return props.begin(); }
 122         Iterator End() { return props.end(); }
 123         ConstIterator End() const { return props.end(); }
 124
 125 private:
 126         std::map<std::string, Value *> props;
 127
 128 };
 129
 130
 131 class Declaration {
 132
 133 public:
 134         Declaration(const std::string &typeName, const std::string &identifier)
 135         : typeName(typeName), identifier(identifier) { }
 136         virtual ~Declaration() { }
 137 private:
 138         Declaration(const Declaration &);
 139         Declaration &operator =(const Declaration &);
 140
 141 public:
 142         const std::string &TypeName() const { return typeName; }
 143         const std::string &Identifier() const { return identifier; }
 144
 145 private:
 146         std::string typeName;
 147         std::string identifier;
 148
 149 };
 150
 151
 152 class Definition
 153 : public Declaration {
 154
 155 public:
 156         Definition(const std::string &typeName, const std::string &identifier)
 157         : Declaration(typeName, identifier), value(0), isLiteral(false) { }
 158         virtual ~Definition();
 159 private:
 160         Definition(const Definition &);
 161         Definition &operator =(const Definition &);
 162
 163 public:
 164         void SetValue(Literal *);
 165         void SetValue(PropertyList *);
 166
 167         bool HasLiteralValue() const { return isLiteral && value; }
 168         bool HasProperties() const { return !isLiteral && value; }
 169         Literal *GetLiteral();
 170         const Literal *GetLiteral() const;
 171         PropertyList *GetProperties();
 172         const PropertyList *GetProperties() const;
 173
 174 private:
 175         void *value;
 176         bool isLiteral;
 177
 178 };
 179
 180
 181 class ParsedSource {
 182
 183 public:
 184         ParsedSource() { }
 185         ~ParsedSource();
 186 private:
 187         ParsedSource(const ParsedSource &);
 188         ParsedSource &operator =(const ParsedSource &);
 189
 190 public:
 191         void AddDeclaration(Declaration *);
 192         void AddDefinition(Definition *);
 193         void ExportDeclaration(Declaration *);
 194         void ExportIdentifier(const std::string &);
 195
 196         bool IsDeclared(const std::string &) const;
 197         Declaration &GetDeclaration(const std::string &);
 198         const Declaration &GetDeclaration(const std::string &) const;
 199         bool IsDefined(const std::string &) const;
 200         Definition &GetDefinition(const std::string &);
 201         const Definition &GetDefinition(const std::string &) const;
 202
 203         const std::map<std::string, Declaration *> &Declarations() const { return declarations; }
 204         const std::map<std::string, Definition *> &Definitions() const { return definitions; }
 205         const std::set<std::string> &Exports() const { return exports; }
 206
 207 private:
 208         std::map<std::string, Declaration *> declarations;
 209         std::map<std::string, Definition *> definitions;
 210         std::set<std::string> exports;
 211
 212 };
 213
 214 }
 215
 216
 217 namespace std {
 218
 219 ostream &operator <<(ostream &, const loader::ParsedSource &);
 220 ostream &operator <<(ostream &, const loader::Literal &);
 221
 222 }
 223
 224 #endif /* LOADER_PARSEDSOURCE_H_ */