Any.h

Go to the documentation of this file.

#ifndef G3D_Any_h
#define G3D_Any_h

#include "G3D/platform.h"
#include "G3D/Table.h"
#include "G3D/Array.h"
#include "G3D/AtomicInt32.h"
#include "G3D/stringutils.h"
#include <string>

// needed for Token
#include "G3D/TextInput.h"
#include "G3D/TextOutput.h"

#ifdef verify
#undef verify
#endif

namespace G3D {

class TextOutput;

class Any {
public:

 enum Type {NIL, BOOLEAN, NUMBER, STRING, ARRAY, TABLE, EMPTY_CONTAINER};

 static std::string toString(Type t);

 class Source {
 public:
 std::string filename;
 int line;
 int character;

 Source() : line(0), character(0) {}

 void set(const TextInput& ti, const Token& t) {
 filename = ti.filename();
 line = t.line();
 character = t.character();
 }
 };

 typedef Array<Any> AnyArray;
 typedef Table<std::string, Any> AnyTable;

private:

 static void deserializeComment(TextInput& ti, Token& token, std::string& comment);

 union SimpleValue {
 bool b;
 double n;

 inline SimpleValue() : n(0.0) {}
 inline SimpleValue(bool x) : b(x) {}
 inline SimpleValue(double x) : n(x) {}
 };
 
 static const char* PAREN;
 static const char* BRACKET;
 static const char* BRACE;

 class Data {
 public:
 union Value {
 std::string* s;
 Array<Any>* a;
 AnyTable* t;
 inline Value() : s(NULL) {}
 };

 // Needed so that the destructor knows what is in Value
 // and can call its destructor. 
 Type type;
 
 Value value;
 
 std::string comment;

 std::string name;

 std::string includeLine;

 AtomicInt32 referenceCount;

 Source source;

 const char* bracket;

 char separator;

 private:

 inline Data(Type t, const char* b, char s) : type(t), referenceCount(1), bracket(b), separator(s) {}

 ~Data();

 public:

 static Data* create(const Data* d);
 static Data* create(Type t, const char* b = NULL, char s = '\0');

 static void destroy(Data* d);
 };

 std::string m_placeholderName;

 Type m_type;
 SimpleValue m_simpleValue;
 mutable Data* m_data;

 void beforeRead() const;

 void beforeWrite();

 void dropReference();

 void ensureData();

 void ensureMutable();

 void deserializeBody(TextInput& ti, Token& token);

 void deserialize(TextInput& ti, Token& token);

 static void deserializeName(TextInput& ti, Token& token, std::string& name);
 
 static void readUntilSeparatorOrClose(TextInput& ti, Token& token);

 Any(const std::string& key, Data* data);

 bool isPlaceholder() const {
 return ! m_placeholderName.empty();
 }
 
 void _append(const Any& v0);
 void _append(const Any& v0, const Any& v1);
 void _append(const Any& v0, const Any& v1, const Any& v2);
 void _append(const Any& v0, const Any& v1, const Any& v2, const Any& v3);
 Any _get(const std::string& key, const Any& defaultVal) const;
 void _set(const std::string& key, const Any& val);

 void _parse(const std::string& src);

public:

 class KeyNotFound : public ParseError {
 public:
 std::string key;

 KeyNotFound(const Data* data) {
 if (data) {
 filename = data->source.filename;
 line = data->source.line;
 character = data->source.character;
 }
 }
 };

 class IndexOutOfBounds : public ParseError {
 public:
 int index;
 int size;
 IndexOutOfBounds() : index(0), size(0) {}
 IndexOutOfBounds(const Data* data, int i, int s) : index(i), size(s) {
 if (data) {
 filename = data->source.filename;
 line = data->source.line;
 character = data->source.character;
 }
 message = format("Index out of bounds: index = %d, array size = %d", i, s);
 }
 };

 Any();

 explicit Any(TextInput& t);

 Any(const Any& x);

 explicit Any(double x);

 explicit Any(float x);

 #if defined(G3D_32Bit) || defined(_MSC_VER)

 explicit Any(int64 x) : m_type(NUMBER), m_simpleValue((double)x), m_data(NULL) {}
 #endif

 explicit Any(long x);

 explicit Any(int x);

 explicit Any(char x);

 explicit Any(short x);

 explicit Any(bool x);

 explicit Any(const std::string& x);

 explicit Any(const char* x);

 explicit Any(Type t, const std::string& name = "", const std::string& brackets = "", const char separator = '\0');

 template<class T>
 explicit Any(const T& v) : m_type(NIL), m_data(NULL) {
 *this = v.toAny();
 }

 ~Any();

 Any& operator=(const Any& x);

 Any& operator=(Type t);

 template<class T>
 Any& operator=(const Array<T>& array) {
 *this = Any::ARRAY;
 resize(array.size());
 for (int i = 0; i < array.size(); ++i) {
 this->operator [](i) = array[i];
 }
 return *this;
 }

 template<class T>
 Any& operator=(const T& v) {
 *this = Any(v);
 return *this;
 }

 Type type() const;

 static Any parse(const std::string& src);

 std::string unparse(const TextOutput::Settings& s = TextOutput::Settings()) const;

 std::string unparseJSON(const TextOutput::Settings& s = TextOutput::Settings(), bool allowCoercion = true) const;
 
 const std::string& comment() const;
 void setComment(const std::string& c);

 bool isNil() const;

 double number() const;
 float floatValue() const;

 const std::string& string() const;
 bool boolean() const;

 std::string resolveStringAsFilename(bool errorIfNotFound = true) const;

 const std::string& name() const;

 bool nameBeginsWith(const std::string& s) const;

 bool nameBeginsWith(const char* s) const;

 bool nameEquals(const std::string& s) const;

 bool nameEquals(const char* s) const;

 void setName(const std::string& name);

 int size() const;
 int length() const;

 const Any& operator[](int i) const;
 Any& operator[](int i);

 const Any& last() const {
 return (*this)[size() - 1];
 }

 Any& last() {
 return (*this)[size() - 1];
 }

 const Array<Any>& array() const;

 template<class T0>
 void append(const T0& v0) {
 _append(Any(v0));
 }

 template<class T0, class T1>
 void append(const T0& v0, const T1& v1) {
 _append(Any(v0), Any(v1));
 }

 template<class T0, class T1, class T2>
 void append(const T0& v0, const T1& v1, const T2& v2) {
 _append(Any(v0), Any(v1), Any(v2));
 }

 template<class T0, class T1, class T2, class T3>
 void append(const T0& v0, const T1& v1, const T2& v2, const T3& v3) {
 _append(Any(v0), Any(v1), Any(v2), Any(v3));
 }

 const Table<std::string, Any>& table() const;

 const Any& operator[](const std::string& key) const;

 // Needed to prevent the operator[](int) overload from catching
 // string literals
 const Any& operator[](const char* key) const {
 return operator[](std::string(key));
 }

 Any& operator[](const std::string& key);

 inline Any& operator[](const char* key) {
 return operator[](std::string(key));
 }
 
 template<class T>
 Any get(const std::string& key, const T& defaultVal) const {
 return _get(key, Any(defaultVal));
 }

 bool containsKey(const std::string& key) const;
 
 template<class T>
 void set(const std::string& key, const T& val) {
 _set(key, Any(val));
 }

 Any& next();

 std::string sourceDirectory() const;

 bool operator==(const Any& x) const;

 bool operator==(const std::string& s) const {
 return *this == Any(s);
 }

 bool operator==(const double& v) const {
 return *this == Any(v);
 }

 bool operator==(int v) const {
 return *this == Any(v);
 }

 bool operator==(bool v) const {
 return *this == Any(v);
 }

 bool operator!=(const Any& x) const;

 bool operator!=(const std::string& s) const {
 return *this != Any(s);
 }

 bool operator!=(const double& v) const {
 return *this != Any(v);
 }

 bool operator!=(int v) const {
 return *this != Any(v);
 }

 bool operator!=(bool v) const {
 return *this != Any(v);
 }

 operator int() const;
 operator uint32() const;
 operator float() const;
 operator double() const;
 operator bool() const;
 operator std::string() const;

 operator char() const {
 return char(int(*this));
 }

 operator uint8() const {
 return uint8(int(*this));
 }

 operator int16() const {
 return int16(int(*this));
 }

 operator uint16() const {
 return uint16(int(*this));
 }

 void resize(int n);

 void clear();

 void load(const std::string& filename);

 static Any fromFile(const std::string& filename);

 void loadIfExists(const std::string& filename);

 void save(const std::string& filename) const;

 void serialize(TextOutput& to, bool json = false, bool coerce = false) const;

 void serialize(class BinaryOutput& b) const;

 void deserialize(TextInput& ti);

 void deserialize(class BinaryInput& b);

 const Source& source() const;

 void remove(const std::string& key);

 void remove(int index);
 
 void verify(bool value, const std::string& message = "") const;


 void verifyName(const std::string& n) const;

 void verifyName(const std::string& n, const std::string& m) const;

 void verifyName(const std::string& n, const std::string& m, const std::string& p) const;

 void verifyName(const std::string& n, const std::string& m, const std::string& p, const std::string& q) const;

 void verifyNameBeginsWith(const std::string& n) const;

 void verifyNameBeginsWith(const std::string& n, const std::string& m) const;

 void verifyNameBeginsWith(const std::string& n, const std::string& m, const std::string& p) const;

 void verifyNameBeginsWith(const std::string& n, const std::string& m, const std::string& p, const std::string& q) const;

 void verifyNameBeginsWith(const std::string& n, const std::string& m, const std::string& p, const std::string& q, const std::string& r) const;

 void verifyNameBeginsWith(const std::string& n, const std::string& m, const std::string& p, const std::string& q, const std::string& r, const std::string& s) const;

 void verifyNameBeginsWith(const std::string& n, const std::string& m, const std::string& p, const std::string& q, const std::string& r, const std::string& s, const std::string& t) const;

 void verifyType(Type t) const;

 void verifyType(Type t0, Type t1) const;

 void verifySize(int low, int high) const;

 void verifySize(int s) const;

 template<class T>
 explicit Any(const Array<T>& array, const std::string& name = "") : m_type(ARRAY), m_data(NULL) {
 setName(name);
 resize(array.size());
 for (int i = 0; i < array.size(); ++i) {
 (*this)[i] = Any(array[i]);
 }
 }

 template<class T>
 void getArray(Array<T>& array) const {
 verifyType(ARRAY);
 array.resize(size());
 for (int i = 0; i < array.size(); ++i) {
 array[i] = T((*this)[i]);
 }
 }

 template<class T>
 void getTable(Table<std::string, T>& table) const {
 verifyType(TABLE);
 for (Table<std::string, Any>::Iterator it = this->table().begin(); it.isValid(); ++it) {
 table.set(it.key(), T(it.value()));
 }
 }

private:

 void deserializeTable(TextInput& ti);
 void deserializeArray(TextInput& ti,const std::string& term);

 void become(const Type& t);

}; // class Any




class AnyTableReader {
private:
 Any m_any;
 Set<std::string> m_alreadyRead;
public:
 
 AnyTableReader(const std::string& name, const Any& a);

 AnyTableReader(const Any& a);

 bool hasMore() const {
 return m_any.size() > m_alreadyRead.size();
 }

 void verifyDone() const;

 const Any& any() const {
 return m_any;
 }

#if 0

 const std::string& key() const;

 const Any& value() const;

 AnyKeyIterator& operator++();
#endif 

 void get(const std::string& s, std::string& v) {
 v = m_any[s].string();
 m_alreadyRead.insert(s);
 }

 void get(const std::string& s, uint8& v) {
 v = uint8(m_any[s].number());
 m_alreadyRead.insert(s);
 }

 void get(const std::string& s, uint16& v) {
 v = uint16(m_any[s].number());
 m_alreadyRead.insert(s);
 }

 template<class T>
 void get(const std::string& s, Array<T>& v) {
 m_any[s].getArray(v);
 m_alreadyRead.insert(s);
 }
 
 template<class T>
 void get(const std::string& s, Table<std::string, T>& v) {
 m_any[s].getTable(v);
 m_alreadyRead.insert(s);
 }

 template<class ValueType>
 void get(const std::string& s, ValueType& v) {
 v = ValueType(m_any[s]);
 m_alreadyRead.insert(s);
 }

 const Any& operator[](const std::string& s) {
 m_alreadyRead.insert(s);
 return m_any[s];
 }

 template<class ValueType>
 bool getIfPresent(const std::string& s, ValueType& v) {
 if (m_any.containsKey(s)) {
 debugAssertM(! m_alreadyRead.contains(s), "read twice");

 get(s, v);
 return true;
 } else {
 return false;
 }
 }

 bool containsUnread(const std::string& s) const {
 return m_any.containsKey(s) && ! m_alreadyRead.contains(s);
 }

};

} // namespace G3D


#define PARSE_ANY(x) Any::parse(#x)


#endif