wisp_struct.h

Go to the documentation of this file.

/*
 * Copyright 2006-2008 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
 *
 *     http://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_WISP_UTILITY_WISP_STRUCT_H
#define __SSRC_WISP_UTILITY_WISP_STRUCT_H

#include <boost/preprocessor/punctuation/comma_if.hpp>
#include <boost/preprocessor/control/expr_iif.hpp>
#include <boost/preprocessor/comparison/equal.hpp>
#include <boost/preprocessor/comparison/less_equal.hpp>
#include <boost/preprocessor/comparison/greater_equal.hpp>
#include <boost/preprocessor/seq.hpp>
#include <boost/preprocessor/array/elem.hpp>
#include <boost/preprocessor/array/push_front.hpp>
#include <boost/preprocessor/stringize.hpp>
#include <boost/call_traits.hpp>

#include <ssrc/wisp-packages.h>

__BEGIN_NS_SSRC_WISP_UTILITY

// This is a marker type, from which all WISP_STRUCT's are derived,
// to facilitate metaprogramming
// (e.g., std::is_base_of<wisp_struct, derived_type>).
struct wisp_struct {
  template<class Archive> void serialize(Archive & ar, const unsigned int) { }
};

__END_NS_SSRC_WISP_UTILITY

#define __WISP_STRUCT_MEMBER(r, data, arg) \
    BOOST_PP_TUPLE_ELEM(2, 0, arg) BOOST_PP_TUPLE_ELEM(2, 1, arg);

#define __WISP_STRUCT_DEFAULT_INIT_MEMBER(r, data, i, arg) \
  BOOST_PP_COMMA_IF(i) BOOST_PP_TUPLE_ELEM(2, 1, arg)()

#define __WISP_STRUCT_INIT_MEMBER(r, data, i, arg) \
  BOOST_PP_COMMA_IF(i) BOOST_PP_TUPLE_ELEM(2, 1, arg)(BOOST_PP_TUPLE_ELEM(2, 1, arg))

#define __WISP_STRUCT_PARAM(r, in_template, i, arg) \
  BOOST_PP_COMMA_IF(i) BOOST_PP_EXPR_IIF(in_template, typename) boost::call_traits<BOOST_PP_TUPLE_ELEM(2, 0, arg)>::param_type BOOST_PP_TUPLE_ELEM(2, 1, arg)

#define __WISP_STRUCT_PARAM_INIT(r, init, i, arg) \
  BOOST_PP_COMMA_IF(i) BOOST_PP_EXPR_IIF(BOOST_PP_ARRAY_ELEM(0, init), typename) boost::call_traits<BOOST_PP_TUPLE_ELEM(2, 0, arg)>::param_type BOOST_PP_TUPLE_ELEM(2, 1, arg) BOOST_PP_EXPR_IIF(BOOST_PP_GREATER_EQUAL(i, BOOST_PP_ARRAY_ELEM(1, init)), = BOOST_PP_ARRAY_ELEM(BOOST_PP_SUB(BOOST_PP_ADD(i, 2), BOOST_PP_ARRAY_ELEM(1, init)), init))

#define __WISP_STRUCT_SERIALIZE(r, data, arg) & BOOST_PP_TUPLE_ELEM(2, 1, arg)

// Serialization
#define __WISP_STRUCT_SERIALIZE_MEMBERS(members)                        \
  template<class Archive>                                               \
  void serialize(Archive & ar, const unsigned int) {                    \
    ar BOOST_PP_SEQ_FOR_EACH(__WISP_STRUCT_SERIALIZE, _, members);      \
  }                                                                     \

// Equality
#define __WISP_STRUCT_EQOP_TEST(r, data, i, arg) \
  BOOST_PP_EXPR_IF(i, &&) (o1.BOOST_PP_TUPLE_ELEM(2, 1, arg) == o2.BOOST_PP_TUPLE_ELEM(2, 1, arg))

#define __WISP_STRUCT_EQOP(name, seq)                                  \
  friend bool operator==(const name & o1, const name & o2) {    \
    return (BOOST_PP_SEQ_FOR_EACH_I(__WISP_STRUCT_EQOP_TEST, _, seq)); \
  }

// Member visitation.  Visitor object must implement
//   Visitor & operator(const char * const key, const V & value)
// or
//   Visitor & operator(const string & key, const V & value)
// (possibly templatized on V) for each type to be visited.
// Non-const value arg versions can be implemented as well if the visitor
// wants to modify the members.  Operators return *this to allow chaining.
#define __WISP_STRUCT_VISIT_MEMBERS(r, v, arg)                          \
  (BOOST_PP_STRINGIZE(BOOST_PP_TUPLE_ELEM(2, 1, arg)), BOOST_PP_TUPLE_ELEM(2, 1, arg))

// Swig doesn't understand rvalue references
#ifndef SWIG
#define __WISP_STRUCT_VISIT(members)                                    \
  template<typename Visitor>                                            \
  void visit(Visitor && visitor) {                                      \
    visitor BOOST_PP_SEQ_FOR_EACH(__WISP_STRUCT_VISIT_MEMBERS, visitor, members); \
  }                                                                     \
  template<typename Visitor>                                            \
  void visit(Visitor && visitor) const {                                \
    visitor BOOST_PP_SEQ_FOR_EACH(__WISP_STRUCT_VISIT_MEMBERS, visitor, members); \
  }
#else
#define __WISP_STRUCT_VISIT(members)
#endif

// We exclude the struct name { } container for the benefit of client
// code that wants to define its own macros that add extra functionality 
// to the generated structures.
#define __WISP_STRUCT(in_template, name, members)                       \
  BOOST_PP_SEQ_FOR_EACH(__WISP_STRUCT_MEMBER, _, members)               \
  name() :                                                              \
  BOOST_PP_SEQ_FOR_EACH_I(__WISP_STRUCT_DEFAULT_INIT_MEMBER, _, members) { } \
  explicit name(BOOST_PP_SEQ_FOR_EACH_I(__WISP_STRUCT_PARAM, in_template, members)) : \
  BOOST_PP_SEQ_FOR_EACH_I(__WISP_STRUCT_INIT_MEMBER, _, members) { }    \
  __WISP_STRUCT_SERIALIZE_MEMBERS(members)                              \
  __WISP_STRUCT_EQOP(name, members)                                     \
  __WISP_STRUCT_VISIT(members)

#define __WISP_STRUCT_WITH_INIT(in_template, name, members, initializers) \
  BOOST_PP_SEQ_FOR_EACH(__WISP_STRUCT_MEMBER, _, members)               \
  explicit name(BOOST_PP_SEQ_FOR_EACH_I(__WISP_STRUCT_PARAM_INIT, BOOST_PP_ARRAY_PUSH_FRONT(BOOST_PP_ARRAY_PUSH_FRONT(initializers, BOOST_PP_SUB(BOOST_PP_SEQ_SIZE(members), BOOST_PP_ARRAY_SIZE(initializers))), in_template), members)) : \
  BOOST_PP_SEQ_FOR_EACH_I(__WISP_STRUCT_INIT_MEMBER, _, members) { }    \
  __WISP_STRUCT_SERIALIZE_MEMBERS(members)                              \
  __WISP_STRUCT_EQOP(name, members)                                     \
  __WISP_STRUCT_VISIT(members)

#define WISP_STRUCT(name, members)  \
  struct name : public NS_SSRC_WISP_UTILITY::wisp_struct { __WISP_STRUCT(0, name, members) }

#define WISP_STRUCT_T(name, members) \
  struct name : public NS_SSRC_WISP_UTILITY::wisp_struct { __WISP_STRUCT(1, name, members) }

#define WISP_STRUCT_WITH_INIT(name, members, initializers)    \
  struct name : public NS_SSRC_WISP_UTILITY::wisp_struct {  __WISP_STRUCT_WITH_INIT(0, name, members, BOOST_PP_SEQ_TO_ARRAY(initializers)) }

#define WISP_STRUCT_WITH_INIT_T(name, members, initializers)    \
  struct name : public NS_SSRC_WISP_UTILITY::wisp_struct { __WISP_STRUCT_WITH_INIT(1, name, members, BOOST_PP_SEQ_TO_ARRAY(initializers)) }

#endif