acedia/announce.hpp

/*                                                                            *\
**                          Copyright (C) 2009-2010                           **
**       Dominik Charousset < Dominik.Charousset (at) haw-hamburg.de >        **
**                                                                            **
**            MMM       MMMMMM   MMMMMMMMM MMMMMMM   MMM       MMM            **
**           MMMMM     MMMMMMMM  MMMMMMMMM MMMMMMMM  MMM      MMMMM           **
**          MMM MMM   MMM        MMMM      MMM   MMM MMM     MMM MMM          **
**         MMM   MMM  MMM        MMMMMMMMM MMM   MMM MMM    MMM   MMM         **
**        MMMMMMMMMMM MMMM   MMM MMMM      MMM   MMM MMM   MMMMMMMMMMM        **
**       MMM       MMM MMMMMMMM  MMMMMMMMM MMMMMMMM  MMM  MMM       MMM       **
**      MMM         MMM MMMMMM   MMMMMMMMM MMMMMMM   MMM MMM         MMM      **
**                                                                            **
**                                                                            **
** This file is part of the acedia library.                                   **
**                                                                            **
** This library is free software: you can redistribute it and/or modify       **
** it under the terms of the GNU Lesser General Public License as published   **
** by the Free Software Foundation, either version 3 of the License, or       **
** (at your option) any later version.                                        **
**                                                                            **
** This library is distributed in the hope that it will be useful,            **
** but WITHOUT ANY WARRANTY; without even the implied warranty of             **
** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the               **
** GNU Lesser General Public License for more details.                        **
**                                                                            **
** You should have received a copy of the GNU Lesser General Public License   **
** along with acedia. If not, see <http://www.gnu.org/licenses/>.             **
\*                                                                            */

#ifndef ACEDIA_ANNOUNCE_HPP
#define ACEDIA_ANNOUNCE_HPP

#include <boost/cstdint.hpp>
#include <boost/preprocessor/control/if.hpp>
#include <boost/preprocessor/cat.hpp>
#include <boost/preprocessor/arithmetic/sub.hpp>
#include <boost/preprocessor/seq.hpp>
#include <boost/preprocessor/punctuation/paren.hpp>

#include "unit.hpp"
#include "metaclass.hpp"
#include "exceptions.hpp"
#include "acedia_string.hpp"
#include "metaclassimpl.hpp"
#include "anyvalimpl.hpp"
#include "acedia_util.hpp"
#include "acedia_stringlist.hpp"

#define ACEDIA_ANY_VAL_CASE_CLASS_IMPL(class_name)                             \
    namespace acedia { namespace details {                                     \
        template<>                                                             \
        struct AnyValImpl< class_name > : public AnyVal                        \
        {                                                                      \
            virtual MetaClass* metaClass() const                               \
            {                                                                  \
                return MetaClassImpl< class_name >::instance();                \
            }                                                                  \
            virtual void* value() const                                        \
            {                                                                  \
                return (void*) &( class_name ::instance());                    \
            }                                                                  \
            virtual AnyVal* copy() const                                       \
            {                                                                  \
                return new AnyValImpl;                                         \
            }                                                                  \
            virtual bool equals(const AnyVal *other) const                     \
            {                                                                  \
                if (!other) return false;                                      \
                return metaClass() == other->metaClass();                      \
            }                                                                  \
            virtual void serialize(boost::archive::text_oarchive& ar) const    \
            {                                                                  \
                ar << metaClass()->name();                                     \
            }                                                                  \
            static String getInstanceName()                                    \
            {                                                                  \
                String s = acedia::util::eraseWhitespaces( #class_name );      \
                s += "()";                                                     \
            }                                                                  \
            virtual String toString() const                                    \
            {                                                                  \
                static String s = getInstanceName();                           \
                return s;                                                      \
            }                                                                  \
        };                                                                     \
    } }

#define ACEDIA_ANNOUNCE_CLASS_IMPL(class_name, tuple_len)                      \
    namespace acedia { namespace details {                                     \
    template<>                                                                 \
    class MetaClassImpl< class_name > : public MetaClass {                     \
        MetaClassImpl() { }                                                    \
        static int zero;                                                       \
    public:                                                                    \
        const String& name() const {                                           \
            static String n = util::eraseWhitespaces( #class_name );           \
            return n;                                                          \
        }                                                                      \
        AnyVal* deserialize(boost::archive::text_iarchive &ar) const {         \
            AnyValImpl< class_name >* val =                                    \
                new AnyValImpl< class_name >();                                \
            ar >> val->v;                                                      \
            return val;                                                        \
        }                                                                      \
        static MetaClassImpl* instance() {                                     \
            static MetaClassImpl* lw = new MetaClassImpl;                      \
            return lw;                                                         \
        }                                                                      \
        virtual bool isCaseTuple() const { return tuple_len > 0 ; }            \
        virtual unsigned int tupleLenght() const { return tuple_len; }         \
    }; } }

#ifdef ACEDIA_REDUCED_ANNOUNCE
#  define ACEDIA_ANNOUNCE_IMPL(class_name_seq, tuple_len)    \
    ACEDIA_EVAL2(ACEDIA_ANNOUNCE_CLASS_IMPL, ACEDIA_REDUCE_SEQ(ACEDIA_PUSH_DDOTS,class_name_seq), tuple_len)
#else
#  define ACEDIA_ANNOUNCE_IMPL(class_name_seq, tuple_len)    \
    ACEDIA_EVAL2(ACEDIA_ANNOUNCE_CLASS_IMPL, ACEDIA_REDUCE_SEQ(ACEDIA_PUSH_DDOTS,class_name_seq), tuple_len) \
    static const boost::int8_t BOOST_PP_CAT(acedia_ignored_value,ACEDIA_REDUCE_SEQ(ACEDIA_DLINES_IMPLODE,class_name_seq)) = \
    (boost::int8_t) registerMetaClass BOOST_PP_LPAREN() acedia::details::MetaClassImpl< ACEDIA_REDUCE_SEQ(ACEDIA_PUSH_DDOTS,class_name_seq) >::instance() BOOST_PP_RPAREN();
#endif

#define ACEDIA_ANNOUNCE(class_name_seq) ACEDIA_ANNOUNCE_IMPL(class_name_seq, 0)

#define ACEDIA_DECLARE_CASE_CLASS(seq)                                         \
  ACEDIA_OPEN_NAMESPACES_BY(seq)                                               \
  struct ACEDIA_SEQ_LAST(seq) {                                                \
    inline operator acedia::Any() const { return acedia::Any::from(*this); }   \
    inline bool operator==(const                                               \
      ACEDIA_SEQ_LAST(seq) &) const { return true; }                           \
    void serialize(boost::archive::text_oarchive&,                             \
                   const unsigned int) const { }                               \
    void serialize(boost::archive::text_iarchive&,                             \
                   const unsigned int) { }                                     \
  }; ACEDIA_CLOSE_NAMESPACES(BOOST_PP_SEQ_POP_BACK(seq))                       \
  namespace acedia { namespace util {                                          \
    template<> struct IsCaseClass<                                             \
          ACEDIA_REDUCE_SEQ(ACEDIA_PUSH_DDOTS,seq)                             \
        > { enum { VALUE = 1 }; };                                             \
  } }                                                                          \
  ACEDIA_ANNOUNCE( seq )

ACEDIA_ANNOUNCE((bool))
ACEDIA_ANNOUNCE((boost)(int8_t))
ACEDIA_ANNOUNCE((boost)(uint8_t))
ACEDIA_ANNOUNCE((boost)(int16_t))
ACEDIA_ANNOUNCE((boost)(uint16_t))
ACEDIA_ANNOUNCE((boost)(int32_t))
ACEDIA_ANNOUNCE((boost)(uint32_t))
ACEDIA_ANNOUNCE((boost)(int64_t))
ACEDIA_ANNOUNCE((boost)(uint64_t))
ACEDIA_ANNOUNCE((float))
ACEDIA_ANNOUNCE((double))
ACEDIA_ANNOUNCE((acedia)(String))
ACEDIA_ANNOUNCE((acedia)(StringList))

#endif

---