Initial commit

7 files changed, 785 insertions, 0 deletions

diff --git a/antlr4-cpp-runtime-4.9.2-source/install/include/antlr4-runtime/support/Any.h b/antlr4-cpp-runtime-4.9.2-source/install/include/antlr4-runtime/support/Any.h
new file mode 100644
index 0000000..468db98
--- /dev/null
+++ b/antlr4-cpp-runtime-4.9.2-source/install/include/antlr4-runtime/support/Any.h
@@ -0,0 +1,170 @@
+/* Copyright (c) 2012-2017 The ANTLR Project. All rights reserved.
+ * Use of this file is governed by the BSD 3-clause license that
+ * can be found in the LICENSE.txt file in the project root.
+ */
+
+// A standard C++ class loosely modeled after boost::Any.
+
+#pragma once
+
+#include "antlr4-common.h"
+
+#ifdef _MSC_VER
+  #pragma warning(push)
+  #pragma warning(disable: 4521) // 'antlrcpp::Any': multiple copy constructors specified
+#endif
+
+namespace antlrcpp {
+
+template<class T>
+  using StorageType = typename std::decay<T>::type;
+
+struct ANTLR4CPP_PUBLIC Any
+{
+  bool isNull() const { return _ptr == nullptr; }
+  bool isNotNull() const { return _ptr != nullptr; }
+
+  Any() : _ptr(nullptr) {
+  }
+
+  Any(Any& that) : _ptr(that.clone()) {
+  }
+
+  Any(Any&& that) : _ptr(that._ptr) {
+    that._ptr = nullptr;
+  }
+
+  Any(const Any& that) : _ptr(that.clone()) {
+  }
+
+  Any(const Any&& that) : _ptr(that.clone()) {
+  }
+
+  template<typename U>
+  Any(U&& value) : _ptr(new Derived<StorageType<U>>(std::forward<U>(value))) {
+  }
+
+  template<class U>
+  bool is() const {
+    auto derived = getDerived<U>(false);
+
+    return derived != nullptr;
+  }
+
+  template<class U>
+  StorageType<U>& as() {
+    auto derived = getDerived<U>(true);
+
+    return derived->value;
+  }
+
+  template<class U>
+  const StorageType<U>& as() const {
+    auto derived = getDerived<U>(true);
+
+    return derived->value;
+  }
+
+  template<class U>
+  operator U() {
+    return as<StorageType<U>>();
+  }
+
+  template<class U>
+  operator const U() const {
+    return as<const StorageType<U>>();
+  }
+
+  Any& operator = (const Any& a) {
+    if (_ptr == a._ptr)
+      return *this;
+
+    auto * old_ptr = _ptr;
+    _ptr = a.clone();
+
+    if (old_ptr)
+      delete old_ptr;
+
+    return *this;
+  }
+
+  Any& operator = (Any&& a) {
+    if (_ptr == a._ptr)
+      return *this;
+
+    std::swap(_ptr, a._ptr);
+
+    return *this;
+  }
+
+  virtual ~Any();
+
+  virtual bool equals(Any other) const {
+    return _ptr == other._ptr;
+  }
+
+private:
+  struct Base {
+    virtual ~Base() {};
+    virtual Base* clone() const = 0;
+  };
+
+  template<typename T>
+  struct Derived : Base
+  {
+    template<typename U> Derived(U&& value_) : value(std::forward<U>(value_)) {
+    }
+
+    T value;
+
+    Base* clone() const {
+      return clone<>();
+    }
+
+  private:
+    template<int N = 0, typename std::enable_if<N == N && std::is_nothrow_copy_constructible<T>::value, int>::type = 0>
+    Base* clone() const {
+      return new Derived<T>(value);
+    }
+
+    template<int N = 0, typename std::enable_if<N == N && !std::is_nothrow_copy_constructible<T>::value, int>::type = 0>
+    Base* clone() const {
+      return nullptr;
+    }
+
+  };
+
+  Base* clone() const
+  {
+    if (_ptr)
+      return _ptr->clone();
+    else
+      return nullptr;
+  }
+
+  template<class U>
+  Derived<StorageType<U>>* getDerived(bool checkCast) const {
+    typedef StorageType<U> T;
+
+    auto derived = dynamic_cast<Derived<T>*>(_ptr);
+
+    if (checkCast && !derived)
+      throw std::bad_cast();
+
+    return derived;
+  }
+
+  Base *_ptr;
+
+};
+
+  template<> inline
+  Any::Any(std::nullptr_t&& ) : _ptr(nullptr) {
+  }
+
+
+} // namespace antlrcpp
+
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif
diff --git a/antlr4-cpp-runtime-4.9.2-source/install/include/antlr4-runtime/support/Arrays.h b/antlr4-cpp-runtime-4.9.2-source/install/include/antlr4-runtime/support/Arrays.h
new file mode 100644
index 0000000..18e6a8a
--- /dev/null
+++ b/antlr4-cpp-runtime-4.9.2-source/install/include/antlr4-runtime/support/Arrays.h
@@ -0,0 +1,110 @@
+/* Copyright (c) 2012-2017 The ANTLR Project. All rights reserved.
+ * Use of this file is governed by the BSD 3-clause license that
+ * can be found in the LICENSE.txt file in the project root.
+ */
+
+#pragma once
+
+#include "antlr4-common.h"
+
+namespace antlrcpp {
+
+  class ANTLR4CPP_PUBLIC Arrays {
+  public:
+
+    static std::string listToString(const std::vector<std::string> &list, const std::string &separator);
+
+    template <typename T>
+    static bool equals(const std::vector<T> &a, const std::vector<T> &b) {
+      if (a.size() != b.size())
+        return false;
+
+      for (size_t i = 0; i < a.size(); ++i)
+        if (!(a[i] == b[i]))
+          return false;
+
+      return true;
+    }
+
+    template <typename T>
+    static bool equals(const std::vector<T *> &a, const std::vector<T *> &b) {
+      if (a.size() != b.size())
+        return false;
+
+      for (size_t i = 0; i < a.size(); ++i) {
+        if (a[i] == b[i])
+          continue;
+        if (!(*a[i] == *b[i]))
+          return false;
+      }
+
+      return true;
+    }
+
+    template <typename T>
+    static bool equals(const std::vector<Ref<T>> &a, const std::vector<Ref<T>> &b) {
+      if (a.size() != b.size())
+        return false;
+
+      for (size_t i = 0; i < a.size(); ++i) {
+        if (!a[i] && !b[i])
+          continue;
+        if (!a[i] || !b[i])
+          return false;
+        if (a[i] == b[i])
+          continue;
+
+        if (!(*a[i] == *b[i]))
+          return false;
+      }
+
+      return true;
+    }
+
+    template <typename T>
+    static std::string toString(const std::vector<T> &source) {
+      std::string result = "[";
+      bool firstEntry = true;
+      for (auto &value : source) {
+        result += value.toString();
+        if (firstEntry) {
+          result += ", ";
+          firstEntry = false;
+        }
+      }
+      return result + "]";
+    }
+
+    template <typename T>
+    static std::string toString(const std::vector<Ref<T>> &source) {
+      std::string result = "[";
+      bool firstEntry = true;
+      for (auto &value : source) {
+        result += value->toString();
+        if (firstEntry) {
+          result += ", ";
+          firstEntry = false;
+        }
+      }
+      return result + "]";
+    }
+
+    template <typename T>
+    static std::string toString(const std::vector<T *> &source) {
+      std::string result = "[";
+      bool firstEntry = true;
+      for (auto value : source) {
+        result += value->toString();
+        if (firstEntry) {
+          result += ", ";
+          firstEntry = false;
+        }
+      }
+      return result + "]";
+    }
+
+  };
+
+  template <>
+  std::string Arrays::toString(const std::vector<antlr4::tree::ParseTree *> &source);
+}
diff --git a/antlr4-cpp-runtime-4.9.2-source/install/include/antlr4-runtime/support/BitSet.h b/antlr4-cpp-runtime-4.9.2-source/install/include/antlr4-runtime/support/BitSet.h
new file mode 100644
index 0000000..bf849b1
--- /dev/null
+++ b/antlr4-cpp-runtime-4.9.2-source/install/include/antlr4-runtime/support/BitSet.h
@@ -0,0 +1,76 @@
+/* Copyright (c) 2012-2017 The ANTLR Project. All rights reserved.
+ * Use of this file is governed by the BSD 3-clause license that
+ * can be found in the LICENSE.txt file in the project root.
+ */
+
+#pragma once
+
+#include "antlr4-common.h"
+
+namespace antlrcpp {
+
+  class ANTLR4CPP_PUBLIC BitSet : public std::bitset<2048> {
+  public:
+    size_t nextSetBit(size_t pos) const {
+      for (size_t i = pos; i < size(); i++){
+        if (test(i)) {
+          return i;
+        }
+      }
+
+      return INVALID_INDEX;
+    }
+
+    // Prints a list of every index for which the bitset contains a bit in true.
+    friend std::wostream& operator << (std::wostream& os, const BitSet& obj)
+    {
+      os << "{";
+      size_t total = obj.count();
+      for (size_t i = 0; i < obj.size(); i++){
+        if (obj.test(i)){
+          os << i;
+          --total;
+          if (total > 1){
+            os << ", ";
+          }
+        }
+      }
+
+      os << "}";
+      return os;
+    }
+
+    static std::string subStringRepresentation(const std::vector<BitSet>::iterator &begin,
+                                                const std::vector<BitSet>::iterator &end) {
+      std::string result;
+      std::vector<BitSet>::iterator vectorIterator;
+
+      for (vectorIterator = begin; vectorIterator != end; vectorIterator++) {
+        result += vectorIterator->toString();
+      }
+      // Grab the end
+      result += end->toString();
+
+      return result;
+    }
+
+    std::string toString(){
+      std::stringstream stream;
+      stream << "{";
+      bool valueAdded = false;
+      for (size_t i = 0; i < size(); ++i){
+        if (test(i)){
+          if (valueAdded) {
+            stream << ", ";
+          }
+          stream << i;
+          valueAdded = true;
+        }
+      }
+
+      stream << "}";
+      return stream.str();
+    }
+
+  };
+}
diff --git a/antlr4-cpp-runtime-4.9.2-source/install/include/antlr4-runtime/support/CPPUtils.h b/antlr4-cpp-runtime-4.9.2-source/install/include/antlr4-runtime/support/CPPUtils.h
new file mode 100644
index 0000000..fc83503
--- /dev/null
+++ b/antlr4-cpp-runtime-4.9.2-source/install/include/antlr4-runtime/support/CPPUtils.h
@@ -0,0 +1,78 @@
+/* Copyright (c) 2012-2017 The ANTLR Project. All rights reserved.
+ * Use of this file is governed by the BSD 3-clause license that
+ * can be found in the LICENSE.txt file in the project root.
+ */
+
+#pragma once
+
+#include "antlr4-common.h"
+
+namespace antlrcpp {
+
+  std::string join(std::vector<std::string> strings, const std::string &separator);
+  std::map<std::string, size_t> toMap(const std::vector<std::string> &keys);
+  std::string escapeWhitespace(std::string str, bool escapeSpaces);
+  std::string toHexString(const int t);
+  std::string arrayToString(const std::vector<std::string> &data);
+  std::string replaceString(const std::string &s, const std::string &from, const std::string &to);
+  std::vector<std::string> split(const std::string &s, const std::string &sep, int count);
+  std::string indent(const std::string &s, const std::string &indentation, bool includingFirst = true);
+
+  // Using RAII + a lambda to implement a "finally" replacement.
+  struct FinalAction {
+    FinalAction(std::function<void ()> f) : _cleanUp { f } {}
+    FinalAction(FinalAction &&other) :
+	_cleanUp(std::move(other._cleanUp)), _enabled(other._enabled) {
+      other._enabled = false; // Don't trigger the lambda after ownership has moved.
+    }
+    ~FinalAction() { if (_enabled) _cleanUp(); }
+
+    void disable() { _enabled = false; }
+  private:
+    std::function<void ()> _cleanUp;
+    bool _enabled {true};
+  };
+
+  ANTLR4CPP_PUBLIC FinalAction finally(std::function<void ()> f);
+
+  // Convenience functions to avoid lengthy dynamic_cast() != nullptr checks in many places.
+  template <typename T1, typename T2>
+  inline bool is(T2 *obj) { // For pointer types.
+    return dynamic_cast<typename std::add_const<T1>::type>(obj) != nullptr;
+  }
+
+  template <typename T1, typename T2>
+  inline bool is(Ref<T2> const& obj) { // For shared pointers.
+    return dynamic_cast<T1 *>(obj.get()) != nullptr;
+  }
+
+  template <typename T>
+  std::string toString(const T &o) {
+    std::stringstream ss;
+    // typeid gives the mangled class name, but that's all what's possible
+    // in a portable way.
+    ss << typeid(o).name() << "@" << std::hex << reinterpret_cast<uintptr_t>(&o);
+    return ss.str();
+  }
+
+  // Get the error text from an exception pointer or the current exception.
+  std::string what(std::exception_ptr eptr = std::current_exception());
+
+  class SingleWriteMultipleReadLock {
+  public:
+    void readLock();
+    void readUnlock();
+    void writeLock();
+    void writeUnlock();
+
+  private:
+    std::condition_variable _readerGate;
+    std::condition_variable _writerGate;
+
+    std::mutex _mutex;
+    size_t _activeReaders = 0;
+    size_t _waitingWriters = 0;
+    size_t _activeWriters = 0;
+  };
+
+} // namespace antlrcpp
diff --git a/antlr4-cpp-runtime-4.9.2-source/install/include/antlr4-runtime/support/Declarations.h b/antlr4-cpp-runtime-4.9.2-source/install/include/antlr4-runtime/support/Declarations.h
new file mode 100644
index 0000000..a355d9b
--- /dev/null
+++ b/antlr4-cpp-runtime-4.9.2-source/install/include/antlr4-runtime/support/Declarations.h
@@ -0,0 +1,163 @@
+/* Copyright (c) 2012-2017 The ANTLR Project. All rights reserved.
+ * Use of this file is governed by the BSD 3-clause license that
+ * can be found in the LICENSE.txt file in the project root.
+ */
+
+#pragma once
+
+namespace antlr4 {
+  class ANTLRErrorListener;
+  class ANTLRErrorStrategy;
+  class ANTLRFileStream;
+  class ANTLRInputStream;
+  class BailErrorStrategy;
+  class BaseErrorListener;
+  class BufferedTokenStream;
+  class CharStream;
+  class CommonToken;
+  class CommonTokenFactory;
+  class CommonTokenStream;
+  class ConsoleErrorListener;
+  class DefaultErrorStrategy;
+  class DiagnosticErrorListener;
+  class EmptyStackException;
+  class FailedPredicateException;
+  class IllegalArgumentException;
+  class IllegalStateException;
+  class InputMismatchException;
+  class IntStream;
+  class InterpreterRuleContext;
+  class Lexer;
+  class LexerInterpreter;
+  class LexerNoViableAltException;
+  class ListTokenSource;
+  class NoSuchElementException;
+  class NoViableAltException;
+  class NullPointerException;
+  class ParseCancellationException;
+  class Parser;
+  class ParserInterpreter;
+  class ParserRuleContext;
+  class ProxyErrorListener;
+  class RecognitionException;
+  class Recognizer;
+  class RuleContext;
+  class Token;
+  template<typename Symbol> class TokenFactory;
+  class TokenSource;
+  class TokenStream;
+  class TokenStreamRewriter;
+  class UnbufferedCharStream;
+  class UnbufferedTokenStream;
+  class WritableToken;
+
+  namespace misc {
+    class InterpreterDataReader;
+    class Interval;
+    class IntervalSet;
+    class MurmurHash;
+    class Utils;
+    class Predicate;
+  }
+  namespace atn {
+    class ATN;
+    class ATNConfig;
+    class ATNConfigSet;
+    class ATNDeserializationOptions;
+    class ATNDeserializer;
+    class ATNSerializer;
+    class ATNSimulator;
+    class ATNState;
+    enum class ATNType;
+    class AbstractPredicateTransition;
+    class ActionTransition;
+    class ArrayPredictionContext;
+    class AtomTransition;
+    class BasicBlockStartState;
+    class BasicState;
+    class BlockEndState;
+    class BlockStartState;
+    class DecisionState;
+    class EmptyPredictionContext;
+    class EpsilonTransition;
+    class LL1Analyzer;
+    class LexerAction;
+    class LexerActionExecutor;
+    class LexerATNConfig;
+    class LexerATNSimulator;
+    class LexerMoreAction;
+    class LexerPopModeAction;
+    class LexerSkipAction;
+    class LookaheadEventInfo;
+    class LoopEndState;
+    class NotSetTransition;
+    class OrderedATNConfigSet;
+    class ParseInfo;
+    class ParserATNSimulator;
+    class PlusBlockStartState;
+    class PlusLoopbackState;
+    class PrecedencePredicateTransition;
+    class PredicateTransition;
+    class PredictionContext;
+    enum class PredictionMode;
+    class PredictionModeClass;
+    class RangeTransition;
+    class RuleStartState;
+    class RuleStopState;
+    class RuleTransition;
+    class SemanticContext;
+    class SetTransition;
+    class SingletonPredictionContext;
+    class StarBlockStartState;
+    class StarLoopEntryState;
+    class StarLoopbackState;
+    class TokensStartState;
+    class Transition;
+    class WildcardTransition;
+  }
+  namespace dfa {
+    class DFA;
+    class DFASerializer;
+    class DFAState;
+    class LexerDFASerializer;
+    class Vocabulary;
+  }
+  namespace tree {
+    class AbstractParseTreeVisitor;
+    class ErrorNode;
+    class ErrorNodeImpl;
+    class ParseTree;
+    class ParseTreeListener;
+    template<typename T> class ParseTreeProperty;
+    class ParseTreeVisitor;
+    class ParseTreeWalker;
+    class SyntaxTree;
+    class TerminalNode;
+    class TerminalNodeImpl;
+    class Tree;
+    class Trees;
+
+    namespace pattern {
+      class Chunk;
+      class ParseTreeMatch;
+      class ParseTreePattern;
+      class ParseTreePatternMatcher;
+      class RuleTagToken;
+      class TagChunk;
+      class TextChunk;
+      class TokenTagToken;
+    }
+
+    namespace xpath {
+      class XPath;
+      class XPathElement;
+      class XPathLexerErrorListener;
+      class XPathRuleAnywhereElement;
+      class XPathRuleElement;
+      class XPathTokenAnywhereElement;
+      class XPathTokenElement;
+      class XPathWildcardAnywhereElement;
+      class XPathWildcardElement;
+    }
+  }
+}
diff --git a/antlr4-cpp-runtime-4.9.2-source/install/include/antlr4-runtime/support/StringUtils.h b/antlr4-cpp-runtime-4.9.2-source/install/include/antlr4-runtime/support/StringUtils.h
new file mode 100644
index 0000000..d00cc52
--- /dev/null
+++ b/antlr4-cpp-runtime-4.9.2-source/install/include/antlr4-runtime/support/StringUtils.h
@@ -0,0 +1,76 @@
+/* Copyright (c) 2012-2017 The ANTLR Project. All rights reserved.
+ * Use of this file is governed by the BSD 3-clause license that
+ * can be found in the LICENSE.txt file in the project root.
+ */
+
+#pragma once
+
+#include "antlr4-common.h"
+
+#ifdef USE_UTF8_INSTEAD_OF_CODECVT
+#include "utf8.h"
+#endif
+
+namespace antlrcpp {
+
+  // For all conversions utf8 <-> utf32.
+  // I wouldn't prefer wstring_convert because: according to
+  // https://en.cppreference.com/w/cpp/locale/wstring_convert,
+  // wstring_convert is deprecated in C++17.
+  // utfcpp (https://github.com/nemtrif/utfcpp) is a substitution.
+#ifndef USE_UTF8_INSTEAD_OF_CODECVT
+  // VS 2015 and VS 2017 have different bugs in std::codecvt_utf8<char32_t> (VS 2013 works fine).
+  #if defined(_MSC_VER) && _MSC_VER >= 1900 && _MSC_VER < 2000
+    typedef std::wstring_convert<std::codecvt_utf8<__int32>, __int32> UTF32Converter;
+  #else
+    typedef std::wstring_convert<std::codecvt_utf8<char32_t>, char32_t> UTF32Converter;
+  #endif
+#endif
+
+  // The conversion functions fails in VS2017, so we explicitly use a workaround.
+  template<typename T>
+  inline std::string utf32_to_utf8(T const& data)
+  {
+    #ifndef USE_UTF8_INSTEAD_OF_CODECVT
+      // Don't make the converter static or we have to serialize access to it.
+      thread_local UTF32Converter converter;
+
+      #if defined(_MSC_VER) && _MSC_VER >= 1900 && _MSC_VER < 2000
+        const auto p = reinterpret_cast<const int32_t *>(data.data());
+        return converter.to_bytes(p, p + data.size());
+      #else
+        return converter.to_bytes(data);
+      #endif
+    #else
+      std::string narrow;
+      utf8::utf32to8(data.begin(), data.end(), std::back_inserter(narrow));
+      return narrow;
+    #endif
+  }
+
+  inline UTF32String utf8_to_utf32(const char* first, const char* last)
+  {
+    #ifndef USE_UTF8_INSTEAD_OF_CODECVT
+      thread_local UTF32Converter converter;
+
+      #if defined(_MSC_VER) && _MSC_VER >= 1900 && _MSC_VER < 2000
+        auto r = converter.from_bytes(first, last);
+        i32string s = reinterpret_cast<const int32_t *>(r.data());
+        return s;
+      #else
+        std::u32string s = converter.from_bytes(first, last);
+        return s;
+      #endif
+    #else
+      UTF32String wide;
+      utf8::utf8to32(first, last, std::back_inserter(wide));
+      return wide;
+    #endif
+  }
+
+  void replaceAll(std::string &str, std::string const& from, std::string const& to);
+
+  // string <-> wstring conversion (UTF-16), e.g. for use with Window's wide APIs.
+  ANTLR4CPP_PUBLIC std::string ws2s(std::wstring const& wstr);
+  ANTLR4CPP_PUBLIC std::wstring s2ws(std::string const& str);
+}
diff --git a/antlr4-cpp-runtime-4.9.2-source/install/include/antlr4-runtime/support/guid.h b/antlr4-cpp-runtime-4.9.2-source/install/include/antlr4-runtime/support/guid.h
new file mode 100644
index 0000000..b412497
--- /dev/null
+++ b/antlr4-cpp-runtime-4.9.2-source/install/include/antlr4-runtime/support/guid.h
@@ -0,0 +1,112 @@
+/*
+ The MIT License (MIT)
+
+ Copyright (c) 2014 Graeme Hill (http://graemehill.ca)
+
+ Permission is hereby granted, free of charge, to any person obtaining a copy
+ of this software and associated documentation files (the "Software"), to deal
+ in the Software without restriction, including without limitation the rights
+ to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ copies of the Software, and to permit persons to whom the Software is
+ furnished to do so, subject to the following conditions:
+
+ The above copyright notice and this permission notice shall be included in
+ all copies or substantial portions of the Software.
+
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ THE SOFTWARE.
+ */
+#pragma once
+
+#include <iostream>
+#include <vector>
+#include <sstream>
+#include <string>
+#include <iomanip>
+#include <stdint.h>
+
+#ifdef GUID_ANDROID
+#include <jni.h>
+#endif
+
+// Class to represent a GUID/UUID. Each instance acts as a wrapper around a
+// 16 byte value that can be passed around by value. It also supports
+// conversion to string (via the stream operator <<) and conversion from a
+// string via constructor.
+class Guid
+{
+public:
+
+  // create a guid from vector of bytes
+  Guid(const std::vector<unsigned char> &bytes);
+
+  // create a guid from array of bytes
+  Guid(const unsigned char *bytes);
+
+  // Create a guid from array of words.
+  Guid(const uint16_t *bytes, bool reverse);
+
+  // create a guid from string
+  Guid(const std::string &fromString);
+
+  // create empty guid
+  Guid();
+
+  // copy constructor
+  Guid(const Guid &other);
+
+  // overload assignment operator
+  Guid &operator=(const Guid &other);
+
+  // overload equality and inequality operator
+  bool operator==(const Guid &other) const;
+  bool operator!=(const Guid &other) const;
+
+  const std::string toString() const;
+  std::vector<unsigned char>::const_iterator begin() { return _bytes.begin(); }
+  std::vector<unsigned char>::const_iterator end() { return _bytes.end(); }
+  std::vector<unsigned char>::const_reverse_iterator rbegin() { return _bytes.rbegin(); }
+  std::vector<unsigned char>::const_reverse_iterator rend() { return _bytes.rend(); }
+
+
+private:
+
+  // actual data
+  std::vector<unsigned char> _bytes;
+
+  // make the << operator a friend so it can access _bytes
+  friend std::ostream &operator<<(std::ostream &s, const Guid &guid);
+};
+
+// Class that can create new guids. The only reason this exists instead of
+// just a global "newGuid" function is because some platforms will require
+// that there is some attached context. In the case of android, we need to
+// know what JNIEnv is being used to call back to Java, but the newGuid()
+// function would no longer be cross-platform if we parameterized the android
+// version. Instead, construction of the GuidGenerator may be different on
+// each platform, but the use of newGuid is uniform.
+class GuidGenerator
+{
+public:
+#ifdef GUID_ANDROID
+  GuidGenerator(JNIEnv *env);
+#else
+  GuidGenerator() { }
+#endif
+
+  Guid newGuid();
+
+#ifdef GUID_ANDROID
+private:
+  JNIEnv *_env;
+  jclass _uuidClass;
+  jmethodID _newGuidMethod;
+  jmethodID _mostSignificantBitsMethod;
+  jmethodID _leastSignificantBitsMethod;
+#endif
+};