AnyCollection.h

#ifndef ANY_COLLECTION_H
#define ANY_COLLECTION_H

#include <KrisLibrary/Logger.h>
#include "AnyValue.h"
#include <KrisLibrary/errors.h>
#include <vector>
#include <map>
#include <memory>
#include "stl_tr1.h"

struct AnyKeyable
{
  AnyKeyable();
  AnyKeyable(const AnyKeyable& rhs);
  AnyKeyable(bool value);
  AnyKeyable(char value);
  AnyKeyable(unsigned char value);
  AnyKeyable(int value);
  AnyKeyable(unsigned int value);
  AnyKeyable(float value);
  AnyKeyable(double value);
  AnyKeyable(const std::string& value);
  AnyKeyable(const char* value);
  size_t hash() const;
  bool operator == (const AnyKeyable& rhs) const;

  AnyValue value;
};

BEGIN_TR1_NAMESPACE

template <>
struct hash<AnyKeyable> : public unary_function<AnyKeyable,size_t>
{
  size_t operator()(const AnyKeyable& key) const { return key.hash(); }
};

END_TR1_NAMESPACE



class AnyCollection
{
 public:
  typedef std::shared_ptr<AnyCollection> AnyCollectionPtr;

  AnyCollection();
  AnyCollection(AnyValue value);
  template <class T>
  AnyCollection(const std::vector<T>& array);
  template <class T,class T2>
  AnyCollection(const std::map<T,T2>& map);
  template <class T,class T2>
  AnyCollection(const UNORDERED_MAP_TEMPLATE<T,T2>& map);

  size_t size() const;
  bool null() const;
  bool collection() const;
  bool isvalue() const;
  bool isarray() const;
  bool ismap() const;
  size_t depth() const;
  operator const AnyValue& () const;
  operator AnyValue& ();
  //coerce cast to plain data type
  template<class T>
  operator T() const;
  //coerce cast to plain data type
  template<class T>
  bool as(T& value) const;
  //coerce cast a flat array type to a vector
  template<class T>
  bool asvector(std::vector<T>& values) const;
  //retrieve elements of a flat array type
  bool asvector(std::vector<AnyValue>& values) const;
  //test equality with value
  template <class T>
  bool operator == (const T& value) const;
  //test inequality with value
  template <class T>
  bool operator != (const T& value) const { return !operator == (value); }
  //make into an array
  void resize(size_t n);
  //clears to an empty type
  void clear();
  //accessors
  AnyCollectionPtr find(int i) const;
  AnyCollectionPtr find(const char* str) const;
  AnyCollectionPtr find(AnyKeyable key) const;
  AnyCollectionPtr insert(int i);
  AnyCollectionPtr insert(const char* str);
  AnyCollectionPtr insert(AnyKeyable key);
  AnyCollection& operator[](int i);
  const AnyCollection& operator[](int i) const;
  AnyCollection& operator[](const char* str);
  const AnyCollection& operator[](const char* str) const;
  AnyCollection& operator[](AnyKeyable key);
  const AnyCollection& operator[](AnyKeyable key) const;

  void shallow_copy(const AnyCollection& rhs);
  void deep_copy(const AnyCollection& rhs);

  AnyCollection& operator = (const AnyCollection& rhs);
  AnyCollection& operator = (AnyValue value);
  AnyCollection& operator = (bool v) { return operator = (AnyValue(v)); }
  AnyCollection& operator = (char v) { return operator = (AnyValue(v)); }
  AnyCollection& operator = (unsigned char v) { return operator = (AnyValue(v)); }
  AnyCollection& operator = (int v) { return operator = (AnyValue(v)); }
  AnyCollection& operator = (unsigned int v) { return operator = (AnyValue(v)); }
  AnyCollection& operator = (float v) { return operator = (AnyValue(v)); }
  AnyCollection& operator = (double v) { return operator = (AnyValue(v)); }
  AnyCollection& operator = (const std::string& str) { return operator = (AnyValue(str)); }
  AnyCollection& operator = (const char* str) { return operator = (std::string(str)); }
  template <class T>
  AnyCollection& operator = (const std::vector<T>& array);
  template <class T,class T2>
  AnyCollection& operator = (const std::map<T,T2>& map);
  template <class T,class T2>
  AnyCollection& operator = (const UNORDERED_MAP_TEMPLATE<T,T2>& map);

  AnyCollectionPtr lookup(const std::string& reference,bool insert=false,char delim='.',char lbracket='[',char rbracket=']');
  AnyCollectionPtr lookup(const std::vector<std::string>& path,bool insert=false);
  AnyCollectionPtr lookup(const std::vector<AnyKeyable>& path,bool insert=false);
  static bool parse_reference(const std::string& reference,std::vector<std::string>& path,char delim='.',char lbracket='[',char rbracket=']');
  bool match_path(const std::vector<std::string>& path,std::vector<AnyKeyable>& key_path) const;

  AnyCollectionPtr slice(const std::string& reference,const char* delims=".[]:,");

  bool subcollection(const std::vector<std::string>& paths,AnyCollection& subset,const char* delims=".[]:,");

  void enumerate(std::vector<AnyCollectionPtr >& collections) const;
  void enumerate_keys(std::vector<AnyKeyable>& elements) const;
  void enumerate_values(std::vector<AnyValue>& elements) const;
  void enumerate_keys_dfs(std::vector<std::vector<AnyKeyable> >& paths) const;
  void enumerate_values_dfs(std::vector<AnyValue>& elements) const;

  void merge(const AnyCollection& other);
  void deepmerge(const AnyCollection& other);
  bool fill(AnyCollection& universe,bool checkSuperset=false);

  bool read(std::istream& in);
  bool read(const char* data);
  void write(std::ostream& out,int indent=0) const;
  void write_inline(std::ostream& out) const;

 private:
  enum Type { None, Value, Array, Map };
  typedef AnyValue ValueType;
  typedef std::vector<AnyCollectionPtr > ArrayType;
  typedef UNORDERED_MAP_TEMPLATE<AnyKeyable,AnyCollectionPtr > MapType;

  Type type;
  ValueType value;
  ArrayType array;
  MapType map;
};

inline std::istream& operator >> (std::istream& in,AnyCollection& c)
{
  bool res=c.read(in);
  if(!res) in.setstate(std::ios::failbit);
  return in;
}


inline std::ostream& operator << (std::ostream& out,const AnyCollection& c)
{
  c.write(out);
  return out;
}

template <class T>
AnyCollection::AnyCollection(const std::vector<T>& array)
  :type(None)
{
  operator = (array);
}

template <class T,class T2>
AnyCollection::AnyCollection(const std::map<T,T2>& map)
  :type(None)
{
  operator = (map);
}

template <class T,class T2>
AnyCollection::AnyCollection(const UNORDERED_MAP_TEMPLATE<T,T2>& map)
  :type(None)
{
  operator = (map);
}


template<class T>
AnyCollection::operator T() const
{
  T res;
  if(!as(res)) {
    if(type == Value)
      FatalError("AnyCollection: coercion from %s to %s failed\n",value.type().name(),typeid(T).name());
    else if(type == None)
      FatalError("AnyCollection: coersion to %s failed, item does not exist\n",typeid(T).name());
    else
      FatalError("AnyCollection: coersion to %s failed, not of value type\n",typeid(T).name());
  }
  return res;
}

template<class T>
bool AnyCollection::as(T& result) const
{
  if(type == Value) {
    bool res=CoerceCast<T>(value,result);
    return res;
  }
  else {
    return false;
  }
}

template <class T>
bool AnyCollection::operator == (const T& v) const
{
  if(type != Value) return false;
  return value == v;
}

template<class T>
bool AnyCollection::asvector(std::vector<T>& values) const
{
  std::vector<AnyValue> anyvalues;
  if(!asvector(anyvalues)) return false;
  values.resize(anyvalues.size());
  for(size_t i=0;i<values.size();i++) {
    bool res = CoerceCast<T>(anyvalues[i],values[i]);
    if(!res) {
      LOG4CXX_INFO(KrisLibrary::logger(),"Coerce cast "<<anyvalues[i].type().name()<<" to "<<typeid(T).name()<<" failed for element "<<(int)i);
      return false;
    }
  }
  return true;
}


template <class T>
AnyCollection& AnyCollection::operator = (const std::vector<T>& _array)
{
  type = Array;
  array.resize(_array.size());
  for(size_t i=0;i<array.size();i++)
    array[i] = std::make_shared<AnyCollection>(_array[i]);
  return *this;
}

template <class T,class T2>
AnyCollection& AnyCollection::operator = (const std::map<T,T2>& _map)
{
  type = Map;
  for(typename std::map<T,T2>::const_iterator i=_map.begin();i!=_map.end();i++)
    map[i->first] = std::make_shared<AnyCollection>(i->second);
  return *this;
}

template <class T,class T2>
AnyCollection& AnyCollection::operator = (const UNORDERED_MAP_TEMPLATE<T,T2>& _map)
{
  type = Map;
  for(typename UNORDERED_MAP_TEMPLATE<T,T2>::const_iterator i=_map.begin();i!=_map.end();i++)
    map[i->first] = std::make_shared<AnyCollection>(i->second);
  return *this;
}

#endif