yinspire 0.1.0

data/pure_cpp/src/algo/indexed_binary_heap.h

@@ -0,0 +1,90 @@
+/*
+ * An Indexed Binary Heap
+ *
+ * Copyright (c) 2007, 2008 by Michael Neumann (mneumann@ntecs.de)
+ *
+ * The Indexed Binary Heap keeps track of the indices of it's elements
+ * stored in the heap to allow efficient updating of their priorities. 
+ *
+ * The requirement was to modify an elements priority. In a regular
+ * implicit binary heap this is an inefficient operation as the element
+ * has to be found prior to modifying it's priority.  And finding an
+ * element is O(n) in an implicit binary heap due to it's non sorted
+ * nature (i.e. can't apply binary search). By keeping track of the
+ * elements index and storing this value inside the elements structure,
+ * the complexity of modifying an elements priority is reduced to 
+ * O(log n) in the worst-case! 
+ *
+ * NOTE: Index 0 of the elements array is unused.  It's the index that
+ * should be used to denote that an element is NOT actually present in
+ * the binary heap.
+ *
+ * See documentation of BinaryHeap as well.
+ *
+ * Example:
+ *
+ *   struct E
+ *   {
+ *     float schedule_at;
+ *     unsigned int schedule_index;
+ *
+ *     inline static bool less(const E& e1, const E& e2)
+ *     {
+ *       return e1.schedule_at < e2.schedule_at;
+ *     }
+ *
+ *     inline static unsigned int& index(const E& e)
+ *     {
+ *       return e.schedule_index;
+ *     }
+ *   };
+ *
+ *   IndexedBinaryHeap<E, MemoryAllocator> heap;
+ *   ...
+ *
+ */
+
+#ifndef __YINSPIRE__INDEXED_BINARY_HEAP__
+#define __YINSPIRE__INDEXED_BINARY_HEAP__
+
+#include "binary_heap.h"
+
+template <typename E, class Acc=E>
+struct BinaryHeapIndexer
+{
+  static inline void index_changed(E& e, unsigned int i) 
+  {
+    Acc::index(e) = i;
+  }
+};
+
+
+template <typename E, class Alloc, class Acc=E, unsigned int MIN_CAPA=1024> 
+class IndexedBinaryHeap : public BinaryHeap<E, Alloc, Acc, BinaryHeapIndexer<E, Acc>, MIN_CAPA>
+{
+    typedef unsigned int I; // index type
+    typedef BinaryHeap<E, Alloc, Acc, BinaryHeapIndexer<E, Acc>, MIN_CAPA> super;
+    typedef BinaryHeapIndexer<E, Acc> Idx;
+
+  public:
+
+    void
+      update(const E& element)
+      {
+        I i = Acc::index(element);
+        if (i == 0)
+        {
+          super::push(element);
+        }
+        else
+        {
+          // FIXME: use propagate up/down instead
+          Idx::index_changed(this->elements[i], 0);  // detach from heap
+          I bubble = super::move_bubble_down(i);
+          super::insert_and_bubble_up(bubble, element); 
+        }
+      }
+
+};
+
+#endif

data/pure_cpp/src/json/json.cc

@@ -0,0 +1,542 @@
+#include "json.h"
+#include <string.h>
+#include <math.h>
+
+/* TODO:
+ *   output indentation
+ *   escape string (\0 characters in string?)
+ */
+
+struct jsonArrayItem
+{
+  jsonValue* value;
+  jsonArrayItem* next;
+
+  jsonArrayItem(jsonValue* value, jsonArrayItem* next=NULL)
+  {
+    this->value = value;
+    this->next = next;
+    this->value->ref_incr();
+  }
+
+  ~jsonArrayItem()
+  {
+    this->value->ref_decr();
+  }
+};
+
+struct jsonHashItem
+{
+  jsonString* key;
+  jsonValue* value;
+  jsonHashItem* next;
+
+  jsonHashItem(jsonString* key, jsonValue* value, jsonHashItem* next=NULL)
+  {
+    this->key = key;
+    this->value = value;
+    this->next = next;
+
+    this->key->ref_incr();
+    this->value->ref_incr();
+  }
+
+  ~jsonHashItem()
+  {
+    this->key->ref_decr();
+    this->value->ref_decr();
+  }
+};
+
+jsonValue::jsonValue() 
+{
+  this->ref_count = 1;
+}
+
+jsonValue::~jsonValue()
+{
+}
+
+const char* jsonValue::type()
+{
+  return "value";
+}
+
+bool jsonValue::is_type(const char* t)
+{
+  return (strcmp(t, type()) == 0);
+}
+
+void jsonValue::ref_incr()
+{
+  this->ref_count++;
+}
+
+void jsonValue::ref_decr()
+{
+  if (--this->ref_count <= 0) delete this;
+}
+
+jsonNull* jsonValue::asNull()
+{
+  return dynamic_cast<jsonNull*>(this);
+}
+
+jsonTrue* jsonValue::asTrue()
+{
+  return dynamic_cast<jsonTrue*>(this);
+}
+
+jsonFalse* jsonValue::asFalse()
+{
+  return dynamic_cast<jsonFalse*>(this);
+}
+
+jsonNumber* jsonValue::asNumber()
+{
+  return dynamic_cast<jsonNumber*>(this);
+}
+
+jsonString* jsonValue::asString()
+{
+  return dynamic_cast<jsonString*>(this);
+}
+
+jsonArray* jsonValue::asArray()
+{
+  return dynamic_cast<jsonArray*>(this);
+}
+
+jsonHash* jsonValue::asHash()
+{
+  return dynamic_cast<jsonHash*>(this);
+}
+
+void jsonNull::output(std::ostream& s)
+{
+  s << "null";
+}
+const char* jsonNull::type()
+{
+  return "null";
+}
+
+void jsonTrue::output(std::ostream& s)
+{
+  s << "true";
+}
+
+const char* jsonTrue::type()
+{
+  return "true";
+}
+
+void jsonFalse::output(std::ostream& s)
+{
+  s << "false";
+}
+
+const char* jsonFalse::type()
+{
+  return "false";
+}
+
+jsonNumber::jsonNumber(double value)
+{
+  this->value = value;
+}
+
+void jsonNumber::output(std::ostream& s) { 
+  if (isinf(value))
+  {
+    if (value < 0.0)
+    {
+      s << "-Infinity";
+    }
+    else
+    {
+      s << "Infinity";
+    }
+  }
+  else
+  {
+    s << value; 
+  }
+}
+
+const char* jsonNumber::type()
+{
+  return "number";
+}
+
+jsonString::jsonString(std::string& value)
+{
+  this->value = value;
+}
+
+jsonString::jsonString(const char* value)
+{
+  this->value = value;
+}
+
+jsonString::jsonString(const char* _value, int len) : value(_value, len)
+{
+}
+
+void jsonString::output(std::ostream& s)
+{
+  s << '"' << value << '"';
+}
+
+const char* jsonString::type()
+{
+  return "string";
+}
+
+jsonArrayIterator::jsonArrayIterator(jsonArray *array)
+{
+  this->array = array;
+  this->array->ref_incr();
+  this->pos = this->array->head;
+}
+
+jsonArrayIterator::~jsonArrayIterator()
+{
+  this->array->ref_decr();
+}
+
+void jsonArrayIterator::next()
+{
+  if (this->pos != NULL)
+  {
+    this->pos = this->pos->next;
+  }
+}
+
+jsonValue *jsonArrayIterator::current()
+{
+  if (this->pos != NULL)
+  {
+    return this->pos->value;
+  }
+  else
+  {
+    return NULL;
+  }
+}
+
+jsonHashIterator::jsonHashIterator(jsonHash *hash)
+{
+  this->hash = hash;
+  this->hash->ref_incr();
+  this->pos = this->hash->head;
+}
+
+jsonHashIterator::~jsonHashIterator()
+{
+  this->hash->ref_decr();
+}
+
+void jsonHashIterator::next()
+{
+  if (this->pos != NULL)
+  {
+    this->pos = this->pos->next;
+  }
+}
+
+jsonString *jsonHashIterator::current_key()
+{
+  if (this->pos != NULL)
+  {
+    return this->pos->key;
+  }
+  else
+  {
+    return NULL;
+  }
+}
+
+jsonValue *jsonHashIterator::current_value()
+{
+  if (this->pos != NULL)
+  {
+    return this->pos->value;
+  }
+  else
+  {
+    return NULL;
+  }
+}
+
+jsonArray::jsonArray()
+{
+  head = tail = NULL;
+}
+
+jsonArray::~jsonArray()
+{
+  jsonArrayItem* j;
+  for (jsonArrayItem* i=head; i != NULL; )
+  {
+    j = i->next;
+    delete i;
+    i = j;
+  }
+}
+
+void jsonArray::output(std::ostream& s) 
+{
+  s << "[";
+  for (jsonArrayItem* i=head; i != NULL; i=i->next)
+  {
+    if (i != head) s << ", ";
+    i->value->output(s);
+  }
+  s << "]";
+}
+
+void jsonArray::push(jsonValue* value)
+{
+  jsonArrayItem* i = new jsonArrayItem(value);
+
+  if (head == NULL)
+  {
+    head = tail = i; 
+  }
+  else
+  {
+    tail->next = i; 
+    tail = i;
+  }
+}
+
+/*void jsonArray::each(void (*iter)(jsonValue*, void*), void* data)
+{
+  for (jsonArrayItem* i=head; i != NULL; i=i->next)
+  {
+    iter(i->value, data);
+  }
+}
+*/
+
+jsonValue* jsonArray::get(int index)
+{
+  for (jsonArrayItem* i=head; i != NULL; i=i->next, index--)
+  {
+    if (index == 0)
+      return i->value; 
+  }
+  return NULL;
+}
+
+const char* jsonArray::type()
+{
+  return "array";
+}
+
+jsonHash::jsonHash()
+{
+  head = tail = NULL;
+}
+
+jsonHash::~jsonHash()
+{
+  jsonHashItem* j;
+  for (jsonHashItem* i=head; i != NULL; )
+  {
+    j = i->next;
+    delete i;
+    i = j;
+  }
+}
+
+void jsonHash::output(std::ostream& s) 
+{
+  s << "{";
+  for (jsonHashItem* i=head; i != NULL; i=i->next)
+  {
+    if (i != head) s << ", " << std::endl;
+    i->key->output(s);
+    s << ": ";
+    i->value->output(s);
+  }
+  s << "}";
+}
+
+/*void jsonHash::each(void (*iter)(jsonString*, jsonValue*, void*), void* data)
+{
+  for (jsonHashItem* i=head; i != NULL; i=i->next)
+  {
+    iter(i->key, i->value, data);
+  }
+}
+*/
+
+jsonValue* jsonHash::get(const char* key)
+{
+  for (jsonHashItem* i=head; i != NULL; i=i->next)
+  {
+    if (i->key->value == key)
+    {
+      return i->value;
+    }
+  }
+  return NULL;
+}
+
+jsonValue* jsonHash::get(std::string& key)
+{
+  return get(key.c_str());
+}
+
+jsonValue* jsonHash::get(jsonString* key)
+{
+  return get(key->value);
+}
+
+bool jsonHash::has_key(const char* key)
+{
+  return (get(key) != NULL);
+}
+
+bool jsonHash::has_key(std::string& key)
+{
+  return (get(key.c_str()) != NULL);
+}
+
+bool jsonHash::has_key(jsonString* key)
+{
+  return (get(key) != NULL);
+}
+
+bool jsonHash::get_bool(const char* key, bool default_value)
+{
+  jsonValue* v = get(key);
+  if (v != NULL)
+  {
+    if (v->is_type("true"))
+    {
+      return true;
+    }
+    else if (v->is_type("false"))
+    {
+      return false;
+    }
+    else
+    {
+      throw "invalid type cast";
+    }
+  }
+  else
+  {
+    return default_value;
+  }
+}
+
+double jsonHash::get_number(const char* key, double default_value)
+{
+  jsonValue* v = get(key);
+  if (v != NULL)
+  {
+    if (v->is_type("number"))
+    {
+      return ((jsonNumber*)v)->value;
+    }
+    else
+    {
+      throw "invalid type cast";
+    }
+  }
+  else
+  {
+    return default_value;
+  }
+}
+
+std::string& jsonHash::get_string(const char* key)
+{
+  jsonValue* v = get(key);
+  if (v != NULL)
+  {
+    if (v->is_type("string"))
+    {
+      return ((jsonString*)v)->value;
+    }
+    else
+    {
+      throw "invalid type cast";
+    }
+  }
+  else
+  {
+    throw "key not found";
+  }
+}
+
+void jsonHash::set(const char* key, jsonValue* value)
+{
+  set(new jsonString(key), value);
+}
+
+void jsonHash::set(const char* key, double value)
+{
+  set(new jsonString(key), new jsonNumber(value));
+}
+
+void jsonHash::set(const char* key, int value)
+{
+  set(new jsonString(key), new jsonNumber(value));
+}
+
+void jsonHash::set(const char* key, bool value)
+{
+  set(new jsonString(key), value ? (jsonValue*)new jsonTrue() : (jsonValue*)new jsonFalse());
+}
+
+void jsonHash::set(const char* key, const char* value)
+{
+  set(new jsonString(key), new jsonString(value));
+}
+
+void jsonHash::set(const char* key, std::string& value)
+{
+  set(new jsonString(key), new jsonString(value));
+}
+
+void jsonHash::set(jsonString* key, jsonValue* value)
+{
+  if (head == NULL)
+  {
+    head = tail = new jsonHashItem(key, value); 
+  }
+  else
+  {
+    bool duplicate = false;
+
+    for (jsonHashItem* i=head; i != NULL; i=i->next)
+    {
+      if (i->key->value == key->value)
+      {
+        i->key->ref_decr();
+        i->value->ref_decr();
+        i->key = key;
+        i->value = value;
+        duplicate = true;
+        break;
+      }
+    }
+
+    if (!duplicate)
+    {
+      jsonHashItem* t = new jsonHashItem(key, value);
+      tail->next = t; 
+      tail = t;
+    }
+  }
+}
+
+const char* jsonHash::type()
+{
+  return "hash";
+}