utility/Properties.h

Go to the documentation of this file.

/*
 * Copyright 2006-2009 Savarese Software Research Corporation
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     https://www.savarese.com/software/ApacheLicense-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#ifndef __SSRC_WSPR_UTILITY_PROPERTIES_H
#define __SSRC_WSPR_UTILITY_PROPERTIES_H

#include <boost/variant.hpp>
#include <boost/serialization/variant.hpp>
#include <boost/serialization/vector.hpp>
#include <boost/serialization/split_member.hpp>
#include <boost/ptr_container/serialize_ptr_map.hpp>
#include <boost/ptr_container/serialize_ptr_vector.hpp>
#include <cstdint>
#include <climits>
#include <string>
#include <vector>
#include <utility>
#include <cstdarg>

#include <ssrc/wispers/utility/properties_ptr.h>
// <boost/serialization/shared_ptr.hpp> leaks memmory (as of boost 1.41.0)
// and implements features unrequired by Wispers.
#include <ssrc/wispers/utility/serialize_shared_ptr.h>

__BEGIN_NS_SSRC_WSPR_UTILITY

template<typename T>
struct PropTreeValueOps {
  typedef T value_type;
  typedef T storage_type;

  storage_type copy(const value_type & t) const {
    return t;
  }

  void assign(storage_type & s, const value_type & t) const {
    s = t;
  }

  bool equal(const storage_type & a, const storage_type & b) const {
    return (a == b);
  }

  void free(const storage_type & t) const { }

  const storage_type & initial_value() const {
    return DefaultValue;
  }

private:
  static const value_type DefaultValue;
};

template<typename T> typename PropTreeValueOps<T>::value_type const
PropTreeValueOps<T>::DefaultValue = typename PropTreeValueOps<T>::value_type();

template<typename T>
struct PropTreePointerOps {
  typedef T value_type;
  typedef T* storage_type;

  storage_type copy(const value_type & t) const {
    return new value_type(t);
  }

  storage_type copy(const storage_type & t) const {
    if(t == 0)
      return 0;
    return copy(*t);
  }

  void assign(storage_type & s, const value_type & v) const {
    if(s != 0) {
      *s = v;
    } else {
      s = copy(v);
    }
  }

  bool equal(const storage_type a, const storage_type b) const {
    if(a != 0 && b != 0)
      return (*a == *b);
    return (a == b);
  }

  void free(storage_type t) const {
    delete t;
  }

  void assign(storage_type & s, const storage_type & v) const {
    if(s != 0) {
      if(v != 0) {
        *s = *v;
      } else {
        free(s);
        s = 0;
      }
    } else {
      s = copy(v);
    }
  }

  storage_type initial_value() const {
    return 0;
  }
};

template<typename Key, typename Ops, typename TreeType>
class PropTree {
public:
  typedef Key key_type;
  typedef TreeType tree_type;
  typedef Ops operations;
  typedef typename operations::value_type value_type;
  typedef typename operations::storage_type storage_type;

  typedef boost::ptr_map<key_type, tree_type> child_container;
  typedef typename child_container::iterator child_container_iterator;
  typedef typename child_container::const_iterator child_container_const_iterator;
  typedef typename child_container::size_type size_type;
  typedef std::pair<child_container_iterator, bool> insert_result_type;

protected:

  static const operations Value;

  storage_type _value;
  child_container _children;

public:

  PropTree() : _value(Value.initial_value()) { }

  explicit PropTree(const value_type & v) : _value(Value.copy(v)) { }

  // PropTree should not be used as a polymorphic base class.
  /*virtual*/ ~PropTree() {
    Value.free(_value);
  }

  void clear() {
    _children.clear();
  }

  bool is_leaf() const {
    return _children.empty();
  }

  const storage_type & value() const {
    return _value;
  }

  storage_type & value() {
    return _value;
  }

  void set_value(const value_type & v) {
    Value.assign(_value, v);
  }

  child_container_const_iterator child_begin() const {
    return _children.begin();
  }

  child_container_const_iterator child_end() const {
    return _children.end();
  }

  tree_type * find(const key_type & key) {
    child_container_iterator && it = _children.find(key);
    if(it == _children.end())
      return 0;
    return it->second;
  }

  template<typename... P>
  tree_type * find(const key_type & key, const P & ...p) {
    child_container_iterator && it = _children.find(key);
    if(it == _children.end()) {
      return 0;
    }
    return it->second->find(p...);
  }

  const tree_type * find(const key_type & key) const {
    child_container_const_iterator && it = _children.find(key);
    if(it == _children.end())
      return 0;
    return it->second;
  }

  template<typename... P>
  const tree_type * find(const key_type & key, const P & ...p) const {
    child_container_const_iterator && it = _children.find(key);
    if(it == _children.end()) {
      return 0;
    }
    return it->second->find(p...);
  }

  tree_type * set(const value_type & val, const key_type & key) {
    tree_type *tree = find(key);

    if(tree != 0) {
      tree->set_value(val);
    } else {
      // const_cast works around ptr_map design without using std::auto_ptr
      //_children.insert(key, std::auto_ptr<tree_type>(new tree_type(val)));
      _children.insert(const_cast<key_type &>(key), (tree = new tree_type(val)));
    }

    return tree;
  }

  template<typename... P>
  tree_type *
  set(const value_type & val, const key_type & key, const P & ...p) {
    tree_type *tree = find(key);

    if(tree == 0) {
      // const_cast works around ptr_map design without using std::auto_ptr
      //_children.insert(key, std::auto_ptr<tree_type>(tree = new tree_type));
      _children.insert(const_cast<key_type &>(key), (tree = new tree_type));
    }

    return tree->set(val, p...);
  }

  tree_type * create_node(const key_type & key) {
    tree_type *tree = find(key);

    if(tree == 0) {
      // const_cast works around ptr_map design without using std::auto_ptr
      //_children.insert(key, std::auto_ptr<tree_type>(new tree_type));
      _children.insert(const_cast<key_type &>(key), (tree = new tree_type));
    }

    return tree;
  }

  template<typename... P>
  tree_type *
  create_node(const key_type & key, const P & ...p) {
    tree_type *tree = find(key);

    if(tree == 0) {
      // const_cast works around ptr_map design without using std::auto_ptr
      //_children.insert(key, std::auto_ptr<tree_type>(tree = new tree_type));
      _children.insert(const_cast<key_type &>(key), (tree = new tree_type));
    }

    return tree->create_node(p...);
  }

  size_type erase(const key_type & key) {
    return _children.erase(key);
  }

  template<typename... P>
  size_type erase(const key_type & key, const P & ...p) {
    tree_type *tree = find(key);

    if(tree != 0) {
      return tree->erase(p...);
    }

    return 0;
  }

  // Visitor must define enter and leave functions.
  template<typename Visitor>
  void visit(const Visitor & v) {
    for(child_container_iterator && it = _children.begin(),
          && end = _children.end(); it != end;)
    {
      child_container_iterator child = it++;
      tree_type *tree = child->second;
      v.enter(child->first, tree, (it == end));
      if(!tree->is_leaf()) {
        tree->visit(v);
      }
      v.leave(child->first, tree, (it == end));
    }
  }

  template<typename Visitor>
  void visit(const Visitor & v) const {
    for(child_container_const_iterator && it = _children.begin(),
          && end = _children.end(); it != end;)
    {
      child_container_const_iterator child = it++;
      const tree_type *tree = child->second;
      v.enter(child->first, tree, (it == end));
      if(!tree->is_leaf()) {
        tree->visit(v);
      }
      v.leave(child->first, tree, (it == end));
    }
  }

  bool operator==(const tree_type & p) const {
    if(!Value.equal(_value, p._value))
      return false;

    if(_children.size() != p._children.size())
      return false;

    child_container_const_iterator && it1 = _children.begin(),
      && it2 = p._children.begin(), && end1 = _children.end();

    while(it1 != end1) {
      if(it1->first != it2->first || !(*(it1->second) == *(it2->second)))
        return false;
      ++it1;
      ++it2;
    }

    return true;
  }

  // WARNING!  This is a destructive merge with move semantics!
  void merge(tree_type && p) {
    if(!Value.equal(_value, p._value)) {
      Value.free(_value);
      _value = p._value;
      p._value = Value.initial_value();
    }

    child_container_iterator && it1 = _children.begin(),
      && it2 = p._children.begin(), && end1 = _children.end(),
      && end2 = p._children.end();

    while(it2 != end2) {
      if(it1 == end1) {
        _children.transfer(it2, end2, p._children);
        break;
      } else if(it1->first == it2->first) {
        it1->second->merge(std::move(*it2->second));
        ++it1;
        ++it2;
      } else if(it1->first > it2->first) {
        _children.transfer(it2, p._children);
        ++it2;
      } else {
        ++it1;
      }
    }
  }

  // Non-destructive merge.
  void merge(const tree_type & p) {
    if(!Value.equal(_value, p._value)) {
      Value.assign(_value, p._value);
    }

    child_container_iterator && it1 = _children.begin(),
      && end1 = _children.end();
    child_container_const_iterator && it2 = p._children.begin(),
      && end2 = p._children.end();

    while(it2 != end2) {
      if(it1 == end1) {
        _children.insert(it2, end2);
        break;
      } else if(it1->first == it2->first) {
        it1->second->merge(*it2->second);
        ++it1;
        ++it2;
      } else if(it1->first > it2->first) {
        child_container_const_iterator pos = it2;
        _children.insert(pos, ++it2);
      } else {
        ++it1;
      }
    }
  }

  // These functions exist for the benefit of SWIG wrappers.  Do not
  // call from C++ code.  Use variadic templates instead.
  tree_type * va_set(const value_type & val, const std::va_list & ap) {
    key_type *key;
    tree_type *tree = static_cast<tree_type*>(this);

    while((key = va_arg(ap, key_type *)) != 0) {
      child_container & children = tree->_children;
      tree = tree->find(*key);

      if(tree == 0) {
        children.insert(*key, (tree = new tree_type));
        //children.insert(*key, std::auto_ptr<tree_type>(new tree_type));
      }
    }

    tree->set_value(val);

    return tree;
  }

  tree_type * va_list_find(const key_type *key, const std::va_list & ap) {
    tree_type *tree = static_cast<tree_type*>(this);

    do {
      if((tree = tree->find(*key)) == 0) {
        return 0;
      }
    } while((key = va_arg(ap, const key_type *)) != 0);

    return tree;
  }

  tree_type * va_find(const key_type *key, ...) {
    std::va_list ap;

    va_start(ap, key);

    tree_type *result = va_list_find(key, ap);

    va_end(ap);

    return result;
  }

  // These functions exist for supporting keys serialized as a sequence
  // of tokens, making it impossible to call a multi-argument function.
  template<typename Iterator>
  tree_type * iterator_set(const value_type & val,
                           const Iterator & begin,
                           const Iterator & end)
  {
    tree_type *tree = static_cast<tree_type*>(this);

    for(Iterator key = begin; key != end; ++key) {
      child_container & children = tree->_children;
      tree = tree->find(*key);

      if(tree == 0) {
        children.insert(const_cast<key_type &>(*key), (tree = new tree_type));
        //children.insert(*key, std::auto_ptr<tree_type>(new tree_type));
      }
    }

    tree->set_value(val);

    return tree;
  }
  template<typename Iterator>
  size_type iterator_erase(const Iterator & begin,
                           const Iterator & end)
  {
    tree_type *tree = static_cast<tree_type*>(this);
    tree_type *parent = 0;
    Iterator last_key;

    for(Iterator key = begin; key != end; ++key) {
      parent = tree;
      if((tree = tree->find(*key)) == 0) {
        return 0;
      }
      last_key = key;
    }

    if(parent) {
      return parent->erase(*last_key);
    }

    return 0;
  }

  template<typename Iterator>
  tree_type * iterator_find(const Iterator & begin, const Iterator & end) {
    tree_type *tree = static_cast<tree_type*>(this);

    for(Iterator key = begin; key != end; ++key) {
      if((tree = tree->find(*key)) == 0) {
        return 0;
      }
    }

    return tree;
  }

  template<typename Iterator>
  const tree_type * 
  iterator_find(const Iterator & begin, const Iterator & end) const {
    const tree_type *tree = static_cast<const tree_type*>(this);

    for(Iterator key = begin; key != end; ++key) {
      if((tree = tree->find(*key)) == 0) {
        return 0;
      }
    }

    return tree;
  }

  // Serialization support.
  template<class Archive>
  void save(Archive & ar, const unsigned int) const {
    ar << _value << _children;
  }

  template<class Archive>
  void load(Archive & ar, const unsigned int) {
    Value.free(_value);
    _value = Value.initial_value();
    ar >> _value >> _children;
  }

  BOOST_SERIALIZATION_SPLIT_MEMBER()
};

template<typename K, typename T, typename Tr>
typename PropTree<K, T, Tr>::operations
const PropTree<K, T, Tr>::Value = typename PropTree<K, T, Tr>::operations();

enum PropertyType {
  PropertyBool,
  PropertyInt,
  PropertyUInt,
  PropertyInt64,
  PropertyUInt64,
  PropertyDouble,
  PropertyString,
  PropertyPrimitiveArray,
  PropertyArray
};

typedef
boost::variant<bool, std::int32_t, std::uint32_t,
               std::int64_t, std::uint64_t, double,
               std::string>
primitive_property_type;

class Properties;

typedef std::vector<primitive_property_type> primitive_property_vector;
typedef boost::ptr_vector<Properties> property_vector;

typedef
boost::variant<bool, std::int32_t, std::uint32_t,
               std::int64_t, std::uint64_t, double,
               std::string, primitive_property_vector, property_vector>
property_type;

template<typename T>
class property_type_value_extractor : public boost::static_visitor<void> {
  T* & value;

public:

  property_type_value_extractor(T* & value) : value(value) { }

  void operator()(T & v) const { value = &v; }

  template<typename V>
  void operator()(V & v) const { value = 0; }
};


class Properties : public PropTree<std::string,
                                    PropTreePointerOps<property_type>,
                                    Properties>
{
public:
  typedef
  PropTree<std::string, PropTreePointerOps<property_type>, Properties> super;

  Properties() { }

  explicit Properties(const value_type & v) : super(v) { }

  Properties(const Properties & p) {
#ifdef WSPR_DEBUG
    std::cerr << "Properties non-move const copy constructor called\n";
#endif
    if(p._value != 0) {
      set_value(*p._value);
    } else {
      Value.free(_value);
      _value = 0;
    }
    _children = p._children.clone();
  }

  Properties & operator=(const Properties & p) {
#ifdef WSPR_DEBUG
    std::cerr << "Properties non-move assignment operator called\n";
#endif
    if(p._value != 0) {
      set_value(*p._value);
    } else {
      Value.free(_value);
      _value = 0;
    }
    _children = p._children.clone();
    return *this;
  }

  // Begin move semantics.
  explicit Properties(Properties && p) {
    _value = p._value;
    p._value = 0;
    _children = p._children.release();
  }

  Properties & operator=(Properties && p) {
    Value.free(_value);
    _value = p._value;
    p._value = 0;
    _children = p._children.release();
    return *this;
  }
  // End move semantics.

  bool is_null() const {
    return (_value == 0);
  }

  // Work around conversion of string literal values to bool by automatic
  // type coercion in choosing variant constructor.
  template<typename... P>
  Properties * set(const char * const val, const P & ...p) {
    return super::set(std::string(val), p...);
  }

  // Disambiguate type conversions.
#if (LONG_MAX == INT_MAX)
  template<typename... P>
  Properties * set(const long val, const P & ...p) {
    return super::set(static_cast<std::int32_t>(val), p...);
  }

  template<typename... P>
  Properties * set(const unsigned long val, const P & ...p) {
    return super::set(static_cast<std::uint32_t>(val), p...);
  }
#endif

  template<typename... P>
  Properties * set(const char val, const P & ...p) {
    return super::set(static_cast<std::int32_t>(val), p...);
  }

  template<typename... P>
  Properties * set(const signed char val, const P & ...p) {
    return super::set(static_cast<std::int32_t>(val), p...);
  }

  template<typename... P>
  Properties * set(const unsigned char val, const P & ...p) {
    return super::set(static_cast<std::uint32_t>(val), p...);
  }

  template<typename... P>
  Properties * set(const bool val, const P & ...p) {
    return super::set(val, p...);
  }

  template<typename... P>
  Properties * set(const std::int32_t val, const P & ...p) {
    return super::set(val, p...);
  }

  template<typename... P>
  Properties * set(const std::uint32_t val, const P & ...p) {
    return super::set(val, p...);
  }

  template<typename... P>
  Properties * set(const std::int16_t val, const P & ...p) {
    return super::set(static_cast<std::int32_t>(val), p...);
  }

  template<typename... P>
  Properties * set(const std::uint16_t val, const P & ...p) {
    return super::set(static_cast<std::int32_t>(val), p...);
  }

  template<typename... P>
  Properties * set(const std::int64_t val, const P & ...p) {
    return super::set(val, p...);
  }

  template<typename... P>
  Properties * set(const std::uint64_t val, const P & ...p) {
    return super::set(val, p...);
  }

  template<typename... P>
  Properties * set(const float val, const P & ...p) {
    return super::set(static_cast<double>(val), p...);
  }

  template<typename... P>
  Properties * set(const double val, const P & ...p) {
    return super::set(val, p...);
  }

  template<typename... P>
  Properties * set(const value_type & val, const P & ...p) {
    return super::set(val, p...);
  }

  // Do same for iterator_set.
  template<typename Iterator>
  Properties * iterator_set(const char * const val,
                            const Iterator & begin,
                            const Iterator & end)
 {
    return super::iterator_set(std::string(val), begin, end);
  }

#if (LONG_MAX == INT_MAX)
  template<typename Iterator>
  Properties * iterator_set(const long val,
                            const Iterator & begin,
                            const Iterator & end)
 {
    return super::iterator_set(static_cast<std::int32_t>(val), begin, end);
  }

  template<typename Iterator>
  Properties * iterator_set(const unsigned long val,
                            const Iterator & begin,
                            const Iterator & end)
 {
    return super::iterator_set(static_cast<std::uint32_t>(val), begin, end);
  }
#endif

  template<typename Iterator>
  Properties * iterator_set(const char val,
                            const Iterator & begin,
                            const Iterator & end)
  {
    return super::iterator_set(static_cast<std::int32_t>(val), begin, end);
  }

  template<typename Iterator>
  Properties * iterator_set(const signed char val,
                            const Iterator & begin,
                            const Iterator & end)
  {
    return super::iterator_set(static_cast<std::int32_t>(val), begin, end);
  }

  template<typename Iterator>
  Properties * iterator_set(const unsigned char val,
                            const Iterator & begin,
                            const Iterator & end)
  {
    return super::iterator_set(static_cast<std::uint32_t>(val), begin, end);
  }

  template<typename Iterator>
  Properties * iterator_set(const bool val,
                            const Iterator & begin,
                            const Iterator & end)
  {
    return super::iterator_set(val, begin, end);
  }

  template<typename Iterator>
  Properties * iterator_set(const std::int32_t val,
                            const Iterator & begin,
                            const Iterator & end)
  {
    return super::iterator_set(val, begin, end);
  }

  template<typename Iterator>
  Properties * iterator_set(const std::uint32_t val,
                            const Iterator & begin,
                            const Iterator & end)
  {
    return super::iterator_set(val, begin, end);
  }

  template<typename Iterator>
  Properties * iterator_set(const std::int64_t val,
                            const Iterator & begin,
                            const Iterator & end)
  {
    return super::iterator_set(val, begin, end);
  }

  template<typename Iterator>
  Properties * iterator_set(const std::uint64_t val,
                            const Iterator & begin,
                            const Iterator & end)
  {
    return super::iterator_set(val, begin, end);
  }

  template<typename Iterator>
  Properties * iterator_set(const float val,
                            const Iterator & begin,
                            const Iterator & end)
  {
    return super::iterator_set(static_cast<double>(val), begin, end);
  }

  template<typename Iterator>
  Properties * iterator_set(const double val,
                            const Iterator & begin,
                            const Iterator & end)
  {
    return super::iterator_set(val, begin, end);
  }

  template<typename Iterator>
  Properties * iterator_set(const value_type & val,
                            const Iterator & begin,
                            const Iterator & end)
  {
    return super::iterator_set(val, begin, end);
  }

  template<typename T>
  T* get_ptr() const {
    T* result = 0;

    if(_value != 0) {
      boost::apply_visitor(property_type_value_extractor<T>(result), *_value);
    }

    return result;
  }

  template<typename T, typename... P>
  T* get_ptr(const P & ...p) const {
    const Properties *result = find(p...);

    if(result != 0)
      return result->get_ptr<T>();

    return 0;
  }

  property_vector & create_property_vector() {
    set_value(property_vector());
    return *get_ptr<property_vector>();
  }

  template<typename... P>
  property_vector & create_property_vector(const P & ...p) {
    return *(set(property_vector(), p...)->get_ptr<property_vector>());
  }

  primitive_property_vector & create_primitive_property_vector() {
    set_value(primitive_property_vector());
    return *get_ptr<primitive_property_vector>();
  }

  template<typename... P>
  primitive_property_vector & create_primitive_property_vector(const P & ...p) {
    return *(set(primitive_property_vector(), p...)->get_ptr<primitive_property_vector>());
  }

  template<typename T>
  const T & get(const T & default_value = T()) const {
    T* result = get_ptr<T>();

    if(result != 0) {
      return (*result);
    }

    return default_value;
  }

  template<typename T, typename... P>
  const T & get(const T & default_value, const P & ...p) const {
    T* result = get_ptr<T>(p...);

    if(result != 0)
      return (*result);

    return default_value;
  }

  // These functions exist for the benefit of SWIG wrappers.  Do not
  // call from C++ code.  Use variadic templates instead.

  template<typename T>
  void va_set(const T & val, ...) {
    std::va_list ap;

    va_start(ap, val);

    super::va_set(val, ap);

    va_end(ap);
  }

  template<class Archive>
  void serialize(Archive & ar, const unsigned int) {
    ar & boost::serialization::base_object<super>(*this);
  }
};


template<typename T, typename Archive>
T load_property(Archive & ar) {
  T value;
  ar >> value;
  return value;
}

template<typename V, typename Archive>
void load_property_vector(Archive & ar, property_type & p)
  SSRC_DECL_THROW(boost::bad_get)
{
  p = V();
  ar >> boost::get<V>(p);
}

__END_NS_SSRC_WSPR_UTILITY

// We need to specialize variant load to avoid copy of ptr_vector.
// We use boost variant save unchanged.
namespace boost {
  namespace serialization {
    template<class Archive>
    void load(Archive & ar, NS_SSRC_WSPR_UTILITY::property_type & p,
              const unsigned int)
    {
      using namespace NS_SSRC_WSPR_UTILITY;

      int which;
      ar >> which;
      switch(which) {
      case PropertyBool:   p = load_property<bool>(ar); break;
      case PropertyInt:    p = load_property<std::int32_t>(ar); break;
      case PropertyUInt:   p = load_property<std::uint32_t>(ar); break;
      case PropertyInt64:  p = load_property<std::int64_t>(ar); break;
      case PropertyUInt64: p = load_property<std::uint64_t>(ar); break;
      case PropertyDouble: p = load_property<double>(ar); break;
      case PropertyString: p = load_property<std::string>(ar); break;
      case PropertyPrimitiveArray:
        load_property_vector<primitive_property_vector>(ar, p);
        break;
      case PropertyArray:
        load_property_vector<property_vector>(ar, p);
        break;
      default:
        throw boost::archive::archive_exception(boost::archive::archive_exception::unsupported_version);
        break;
      };
    }
  }
}

BOOST_CLASS_TRACKING(NS_SSRC_WSPR_UTILITY::primitive_property_type, boost::serialization::track_never)
BOOST_CLASS_TRACKING(NS_SSRC_WSPR_UTILITY::property_type, boost::serialization::track_never)
BOOST_CLASS_TRACKING(NS_SSRC_WSPR_UTILITY::primitive_property_vector, boost::serialization::track_never)
BOOST_CLASS_TRACKING(NS_SSRC_WSPR_UTILITY::property_vector, boost::serialization::track_never)
BOOST_CLASS_TRACKING(NS_SSRC_WSPR_UTILITY::Properties, boost::serialization::track_never)

#endif