/* /libs/serialization/xml_performance/macro.hpp *******************************

(C) Copyright 2010 Bryce Lelbach

Use, modification and distribution is subject to the Boost Software License,
Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at 
http://www.boost.org/LICENSE_1_0.txt)

*******************************************************************************/

#if !defined(BOOST_SERIALIZATION_XML_PERFORMANCE_MACRO_HPP)
#define BOOST_SERIALIZATION_XML_PERFORMANCE_MACRO_HPP

#if defined(_MSC_VER)
  #pragma once
#endif

#include <boost/preprocessor.hpp>

#if !defined(BSL_NODE_MAX)
  #define BSL_NODE_MAX 4
#endif

#if !defined(BSL_DEPTH)
  #define BSL_DEPTH 2
#endif

#if !defined(BSL_ROUNDS)
  #define BSL_ROUNDS 256
#endif

#if !defined(BSL_TYPE)
  #define BSL_TYPE int
#endif

#if !defined(BSL_SAVE_TMPFILE)
  #define BSL_SAVE_TMPFILE 0
#endif

#if !defined(BSL_RESULTS_FILE)
  #define BSL_RESULTS_FILE                                \
    BOOST_PP_STRINGIZE(BSL_TYPE)                          \
    BOOST_PP_STRINGIZE(BSL_EXP(BSL_NODE_MAX, BSL_DEPTH))  \
    "_results.xml"                                        \
  /**/
#endif

// utility print macro

#define BSL_PRINT(Z, N, T) T

// preprocessor power function, BSL_EXP

#define BSL_EXP_PRED(B, D) BOOST_PP_TUPLE_ELEM(3, 0, D)

#define BSL_EXP_OP(B, D)                                                       \
   (                                                                           \
      BOOST_PP_DEC(BOOST_PP_TUPLE_ELEM(3, 0, D)),                              \
      BOOST_PP_TUPLE_ELEM(3, 1, D),                                            \
      BOOST_PP_MUL_D(                                                          \
         B,                                                                    \
         BOOST_PP_TUPLE_ELEM(3, 2, D),                                         \
         BOOST_PP_TUPLE_ELEM(3, 1, D)                                          \
      )                                                                        \
   )                                                                           \
   /**/

#define BSL_EXP(X, N)                                                          \
  BOOST_PP_TUPLE_ELEM(                                                         \
    3, 2, BOOST_PP_WHILE(BSL_EXP_PRED, BSL_EXP_OP, (N, X, 1))                  \
  )                                                                            \
  /**/

// boost::archive::xml::node macros

#define BSL_NODE_DECL_MEMBER(Z, N, _)   T ## N  element ## N  ;
#define BSL_NODE_DECL_NONE(Z, N, _)     unused_type  element ## N  ;
#define BSL_NODE_xDECL_CTOR()           node (void) { }

#define BSL_NODE_DECL_CTOR(P)                                                  \
  BOOST_PP_IF(P,                                                               \
    BSL_NODE_xDECL_CTOR,                                                       \
    BOOST_PP_EMPTY                                                             \
  )()                                                                          \
  /**/

#define BSL_NODE_SERIALIZE(Z, N, _)                                            \
  & BOOST_SERIALIZATION_NVP(BOOST_PP_CAT(element, N))                          \
  /**/

#define BSL_NODE_INIT_LIST(Z, N, _)                                            \
  BOOST_PP_COMMA_IF(N)  BOOST_PP_CAT(element, N)                               \
  BOOST_PP_LPAREN() BOOST_PP_CAT(p, N) BOOST_PP_RPAREN()                       \
  /**/

#define BSL_NODE_DECL(Z, N, _)                                                 \
  template<BOOST_PP_ENUM_PARAMS_Z(Z, N, typename T)>                           \
  struct node<                                                                 \
    BOOST_PP_ENUM_PARAMS_Z(Z, N, T)                                            \
    BOOST_PP_COMMA_IF(N)                                                       \
    BOOST_PP_ENUM_ ## Z(BOOST_PP_SUB(BSL_NODE_MAX, N), BSL_PRINT, unused_type) \
  > {                                                                          \
    BOOST_PP_REPEAT_ ## Z(N, BSL_NODE_DECL_MEMBER, _)                          \
                                                                               \
    BOOST_PP_REPEAT_FROM_TO_ ## Z(N, BSL_NODE_MAX, BSL_NODE_DECL_NONE, _)      \
                                                                               \
    template<class ARC>                                                        \
    void serialize (ARC& ar, const unsigned int) {                             \
      ar BOOST_PP_REPEAT_ ## Z(N, BSL_NODE_SERIALIZE, _);                      \
    }                                                                          \
                                                                               \
    BSL_NODE_DECL_CTOR(N)                                                      \
                                                                               \
    node (BOOST_PP_ENUM_BINARY_PARAMS_Z(Z, N, T, p)):                          \
      BOOST_PP_REPEAT_ ## Z(N, BSL_NODE_INIT_LIST, _) { }                      \
  };                                                                           \
  /**/

// instantiation macros

#define BSL_INST_BASE(Z, N, L)                                                 \
  T0 T0 ## _ ## N(BOOST_PP_ENUM_ ## Z(                                         \
    BSL_NODE_MAX, BSL_PRINT,                                                   \
    boost::archive::xml::random<BSL_TYPE> BOOST_PP_LPAREN() BOOST_PP_RPAREN()  \
  ));                                                                          \
  /**/

#define BSL_INST_yNODES(Z, N, L)                                               \
  BOOST_PP_COMMA_IF(N)                                                         \
  BOOST_PP_CAT(T,                                                              \
    BOOST_PP_CAT(BOOST_PP_LIST_AT(L, 1),                                       \
      BOOST_PP_CAT(_,                                                          \
        BOOST_PP_ADD(N,                                                        \
          BOOST_PP_LIST_AT(L, 0)                                               \
        )                                                                      \
      )                                                                        \
    )                                                                          \
  )                                                                            \
  /**/

#define BSL_INST_xNODES(Z, N, L)                                               \
  T ## L T ## L ## _ ## N(                                                     \
    BOOST_PP_REPEAT_ ## Z(                                                     \
      BSL_NODE_MAX, BSL_INST_yNODES,                                           \
      (BOOST_PP_MUL(N, BSL_NODE_MAX), (BOOST_PP_SUB(L, 1), BOOST_PP_NIL))      \
    )                                                                          \
  );                                                                           \
  /**/

#define BSL_INST_NODES(Z, N, L)                                                \
  BOOST_PP_REPEAT_ ## Z(                                                       \
    BSL_EXP(BSL_NODE_MAX, BOOST_PP_SUB(BSL_DEPTH, N)),                         \
    BSL_INST_xNODES, N                                                         \
  )                                                                            \
  /**/

#define BSL_TYPEDEF_NODES(Z, N, L)                                             \
  typedef boost::archive::xml::node<                                           \
    BOOST_PP_ENUM_ ## Z(                                                       \
      BSL_NODE_MAX, BSL_PRINT, BOOST_PP_CAT(T, BOOST_PP_SUB(N, 1))             \
    )                                                                          \
  > T ## N;                                                                    \
  /**/

// main macro

#define BSL_MAIN                                                               \
  int main (void) {                                                            \
    using namespace boost::archive;                                            \
    using namespace boost::archive::xml;                                       \
                                                                               \
    typedef node<BOOST_PP_ENUM(BSL_NODE_MAX, BSL_PRINT, BSL_TYPE)> T0;         \
                                                                               \
    BOOST_PP_REPEAT_FROM_TO(1, BSL_DEPTH, BSL_TYPEDEF_NODES, _)                \
                                                                               \
    typedef node<BOOST_PP_ENUM(                                                \
      BSL_NODE_MAX, BSL_PRINT,                                                 \
      BOOST_PP_CAT(T, BOOST_PP_SUB(BSL_DEPTH, 1))                              \
    )> HEAD;                                                                   \
                                                                               \
    result_set results;                                                        \
    std::size_t rounds = BSL_ROUNDS;                                           \
                                                                               \
    while (rounds --> 0) {                                                     \
      BOOST_PP_REPEAT(BSL_EXP(BSL_NODE_MAX, BSL_DEPTH), BSL_INST_BASE, _)      \
                                                                               \
      BOOST_PP_REPEAT_FROM_TO(1, BSL_DEPTH, BSL_INST_NODES, _)                 \
                                                                               \
      HEAD h(BOOST_PP_ENUM_PARAMS(                                             \
        BSL_NODE_MAX,                                                          \
        BOOST_PP_CAT(T, BOOST_PP_CAT(BOOST_PP_SUB(BSL_DEPTH, 1), _))           \
      ));                                                                      \
                                                                               \
      std::string fn = save_archive(h);                                        \
                                                                               \
      std::pair<double, HEAD> r = restore_archive<HEAD>(fn);                   \
                                                                               \
      std::cout << "round "                                                    \
                << ((BSL_ROUNDS - 1) - rounds)                                 \
                << " -> " << fn << "\n";                                       \
                                                                               \
      BOOST_PP_IF(BSL_SAVE_TMPFILE,                                            \
        BOOST_PP_EMPTY(),                                                      \
        std::remove(fn.c_str());                                               \
      )                                                                        \
                                                                               \
      results.entries.push_back(entry(                                         \
         BOOST_PP_STRINGIZE(BSL_TYPE),                                         \
         BSL_EXP(BSL_NODE_MAX, BSL_DEPTH), r.first                             \
      ));                                                                      \
    }                                                                          \
                                                                               \
    std::fstream fs(BSL_RESULTS_FILE, std::fstream::in);                       \
                                                                               \
    if (fs.good()) {                                                           \
      xml_iarchive ia(fs);                                                     \
      ia >> BOOST_SERIALIZATION_NVP(results);                                  \
      fs.close();                                                              \
    }                                                                          \
                                                                               \
    fs.open(BSL_RESULTS_FILE, std::fstream::out | std::fstream::trunc);        \
    xml_oarchive oa(fs);                                                       \
    oa << BOOST_SERIALIZATION_NVP(results);                                    \
                                                                               \
    fs.close();                                                                \
  }                                                                            \
  /**/

#endif // BOOST_SERIALIZATION_XML_PERFORMANCE_MACRO_HPP