acedia/any.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_ANY_HPP
#define ACEDIA_ANY_HPP

#include <boost/cstdint.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"
#include "announce.hpp"

namespace acedia
{
    namespace details
    {
        // used to "deserialize" null objects
        template<>
        class MetaClassImpl<void> : public MetaClass
        {
            MetaClassImpl() { }
        public:
            const String &name() const { static String n = "void"; return n; }
            AnyVal *deserialize(boost::archive::text_iarchive&) const
            {
                // do nothing and return NULL
                return NULL;
            }
            static MetaClassImpl* instance()
            {
                static MetaClassImpl *lw = new MetaClassImpl();
                return lw;
            }
        };
    }

    namespace details
    {
        template<>
        class MetaClassImpl<Unit> : public MetaClass
        {
            MetaClassImpl() { }

        public:

            const String &name() const
            {
                static String n = "Unit";
                return n;
            }
            AnyVal *deserialize(boost::archive::text_iarchive&) const
            {
                return new AnyValImpl<Unit>();
            }
            static MetaClass* instance()
            {
                static MetaClassImpl *lw = new MetaClassImpl;
                return lw;
            }
            virtual bool isCaseTuple() const { return false; }
        };
    }

    class Any
    {
        friend class AnyArray;
        friend class Message;

        details::AnyVal *val;

        template<typename T>
        T *get_value_as() const
        {
            if (util::IsUnit<T>::VALUE)
            {
                // use a cast to keep the compiler happy for all types
                return reinterpret_cast<T *>(&(Unit::instance()));
            }
            else if (!val) ACEDIA_THROW(NullPointerException, "isNull() == true");
            else if (!instanceOf<T>())
            {
                throw ClassCastException(ACEDIA_FILE_AND_LINE(),
                                         details::MetaClassImpl<T>::instance(),
                                         val->metaClass());
            }
            else return reinterpret_cast<T*>(val->value());
        }

    public:

        // for in-library-use only - may be removed in a further release!
        template<typename T>
        inline const T &uncheckedValue() const
        {
            if (util::IsUnit<T>::VALUE)
            {
                return reinterpret_cast<const T &>(Unit::instance());
            }
            return *(reinterpret_cast<T*>(val->value()));
        }

        /*
         * Constructs an Any object with given value.
         * @note Any takes ownership of @p value
         */
        Any(details::AnyVal *value);

        inline bool valid() throw() { return NULL != val; }

        Any();

        Any(bool);

        Any(boost::int8_t);

        Any(boost::uint8_t);

        Any(boost::int16_t);

        Any(boost::uint16_t);

        Any(boost::int32_t);

        Any(boost::uint32_t);

        Any(boost::int64_t);

        Any(boost::uint64_t);

        Any(float);

        Any(double);

        Any(const char *cstr);

        Any(const String &str);

        Any(const StringList &strList);

        Any(const Any &other);

        ~Any();

        Any &operator=(const Any &other);

        template<typename T>
        void setValue(const T &t)
        {
            if (val) delete val;
            val = new details::AnyValImpl<T>(t);
        }

        template<typename T>
        bool instanceOf() const throw()
        {
            // The types are equal if they point to the same meta class
            if (!val) return false;
            return details::MetaClassImpl<T>::instance() == val->metaClass();
        }

        inline bool instanceOf(MetaClass* mc) const throw()
        {
            return NULL == val ? false : val->metaClass() == mc;
        }

        template<typename T>
        inline const T &value() const
        {
            return *get_value_as<T>();
        }

        template<typename T>
        T &value()
        {
            return *get_value_as<T>();
        }

        void serialize(boost::archive::text_oarchive &ar, const unsigned int unused);
        void serialize(boost::archive::text_iarchive &ar, const unsigned int unused);

        MetaClass *metaClass() const;

        inline const String &typeName() const { return metaClass()->name(); }

        template<typename T>
        inline static Any from(const T &val)
        {
            Any v;
            v.setValue(val);
            return v;
        }

        String toString(bool verbose = false) const;

        bool operator==(const Any &other) const;

        inline bool operator!=(const Any &other) const
        {
            return !((*this) == other);
        }

    };

} // namespace acedia

#endif /* ACEDIA_ANY_H */

---