BindProperties.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_BIND_PROPERTIES_H
#define __SSRC_WSPR_UTILITY_BIND_PROPERTIES_H

#include <ssrc/wisp/utility/wisp_struct.h>
#include <ssrc/wispers/utility/Properties.h>
#include <type_traits>

__BEGIN_NS_SSRC_WSPR_UTILITY

// TODO: find a cleaner way to do this.
template<typename T>
struct is_bindable {
  typedef ssrc::wisp::utility::wisp_struct type;
};

#define WSPR_IS_BINDABLE_SEQUENCE(T)            \
  __BEGIN_NS_SSRC_WSPR_UTILITY                  \
  template<> struct is_bindable<T> {            \
  typedef property_vector type;                 \
  };                                            \
  __END_NS_SSRC_WSPR_UTILITY

#define WSPR_IS_PRIMITIVE_BINDABLE_SEQUENCE(T)  \
  __BEGIN_NS_SSRC_WSPR_UTILITY                  \
  template<> struct is_bindable<T> {            \
  typedef primitive_property_vector type;       \
  };                                            \
  __END_NS_SSRC_WSPR_UTILITY

class BindProperties {
  Properties & properties;

  template<typename V>
  const BindProperties &
  bind(const char * const key, const V & value,
       const std::false_type&, const ssrc::wisp::utility::wisp_struct&) const
  {
    properties.set(value, key);
    return *this;
  }

  template<typename V>
  const BindProperties &
  bind(const char * const key, const V & value,
       const std::true_type&, const ssrc::wisp::utility::wisp_struct&) const
  {
    value.visit(BindProperties(*properties.create_node(key)));
    return *this;
  }

  // Support functions for bindable sequence bind.
  template<typename Iterator>
  static void visit(Iterator & v, Properties & p,
                    const ssrc::wisp::utility::wisp_struct&)
  {
    v->visit(BindProperties(p));
  }

  template<typename Iterator>
  static void visit(Iterator & v, Properties & p,
                    const primitive_property_vector&)
  {
    primitive_property_vector & pv = p.create_primitive_property_vector();

    for(typename Iterator::value_type::const_iterator it = v->begin(),
          && end = v->end(); it != end; ++it)
    {
      pv.push_back(*it);
    }
  }

  template<typename Iterator>
  static void visit(Iterator & v, Properties & p, const property_vector&)
  {
    property_vector & pv = p.create_property_vector();

    for(typename Iterator::value_type::const_iterator it = v->begin(),
          && end = v->end(); it != end; ++it)
    {
      pv.push_back(new Properties);
      visit(it, pv.back(), typename is_bindable<typename Iterator::value_type::value_type>::type());
    }
  }

  // For bindable sequences.
  template<typename V>
  const BindProperties &
  bind(const char * const key, const V & value,
       const std::false_type&, const primitive_property_vector&) const
  {
    primitive_property_vector & pv =
      properties.create_primitive_property_vector(key);

    for(typename V::const_iterator it = value.begin(), && end = value.end();
        it != end; ++it)
    {
      pv.push_back(*it);
    }

    return *this;
  }

  template<typename V>
  const BindProperties &
  bind(const char * const key, const V & value,
       const std::false_type&, const property_vector&) const
  {
    property_vector & pv = properties.create_property_vector(key);

    for(typename V::const_iterator it = value.begin(), && end = value.end();
        it != end; ++it)
    {
      pv.push_back(new Properties);
      visit(it, pv.back(),
            typename is_bindable<typename V::value_type>::type());
    }

    return *this;
  }

public:

  explicit BindProperties(Properties & properties) : properties(properties) { }

  template<typename V>
  const BindProperties &
  operator()(const char * const key, const V & value) const {
    return bind(key, value,
                typename std::is_base_of<ssrc::wisp::utility::wisp_struct, V>::type(),
                typename is_bindable<V>::type());
  }
};

__END_NS_SSRC_WSPR_UTILITY

#endif