any.h

Go to the documentation of this file.

/*
 * Copyright (c) 2016, Shogun-Toolbox e.V. <shogun-team@shogun-toolbox.org>
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *
 *  1. Redistributions of source code must retain the above copyright notice,
 *     this list of conditions and the following disclaimer.
 *
 *  2. Redistributions in binary form must reproduce the above copyright
 *     notice, this list of conditions and the following disclaimer in the
 *     documentation and/or other materials provided with the distribution.
 *
 *  3. Neither the name of the copyright holder nor the names of its
 *     contributors may be used to endorse or promote products derived from
 *     this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 *
 * Written (W) 2016 Sergey Lisitsyn
 * Written (W) 2016 Sanuj Sharma
 */

#ifndef _ANY_H_
#define _ANY_H_

#include <string.h>
#include <stdexcept>
#include <typeinfo>
#include <cxxabi.h>

namespace shogun
{
    template <typename T>
    std::string demangledType()
    {
        size_t length;
        int status;
        char* demangled = abi::__cxa_demangle(typeid(T).name(), nullptr, &length, &status);
        std::string demangled_string(demangled);
        free(demangled);
        return demangled_string;
    }

    class BaseAnyPolicy
    {
    public:
        virtual void set(void** storage, const void* v) const = 0;
        
        virtual void clear(void** storage) const = 0;
        
        virtual std::string type() const = 0;
        
        virtual bool matches(const std::type_info& ti) const = 0;

        virtual bool equals(void** storage, void** other_storage) const = 0;
    };
    
    template <typename T>
    class PointerValueAnyPolicy : public BaseAnyPolicy
    {
    public:
        virtual void set(void** storage, const void* v) const
        {
            *(storage) = new T(*reinterpret_cast<T const*>(v));
        }
        
        virtual void clear(void** storage) const
        {
            delete reinterpret_cast<T*>(*storage);
        }
        
        virtual std::string type() const
        {
            return demangledType<T>();
        }
        
        virtual bool matches(const std::type_info& ti) const
        {
            return typeid(T) == ti;
        }

        bool equals(void** storage, void** other_storage) const
        {
            T typed_storage = *(reinterpret_cast<T*>(*storage));
            T typed_other_storage = *(reinterpret_cast<T*>(*other_storage));
            return typed_storage == typed_other_storage;
        }
    };

    class Any
    {
    public:
        struct Empty;

        Any() : policy(select_policy<Empty>()), storage(nullptr)
        {
        }

        template <typename T>
        explicit Any(const T& v) : policy(select_policy<T>()), storage(nullptr)
        {
            policy->set(&storage, &v);
        }

        Any(const Any& other) : policy(other.policy), storage(nullptr)
        {
            policy->set(&storage, other.storage);
        }

        Any& operator=(const Any& other)
        {
            policy->clear(&storage);
            policy = other.policy;
            policy->set(&storage, other.storage);
            return *(this);
        }

        friend inline bool operator==(const Any& lhs, const Any& rhs);

        friend inline bool operator!=(const Any& lhs, const Any& rhs);

        ~Any()
        {
            policy->clear(&storage);
        }

        template <typename T>
        T& as() const
        {
            if (same_type<T>())
            {
                return *(reinterpret_cast<T*>(storage));
            } 
            else 
            {
                throw std::logic_error("Bad cast to " + demangledType<T>() + 
                        " but the type is " + policy->type());
            }
        }

        template <typename T>
        inline bool same_type() const
        {
            return (policy == select_policy<T>()) || same_type_fallback<T>();
        }

        template <typename T>
        bool same_type_fallback() const
        {
            return policy->matches(typeid(T));
        }

        bool empty() const
        {
            return same_type<Empty>();
        }
    private:
        template <typename T>
        static BaseAnyPolicy* select_policy()
        {
            typedef PointerValueAnyPolicy<T> Policy;
            static Policy policy;
            return &policy;
        }

        BaseAnyPolicy* policy;
        void* storage;
    };

    inline bool operator==(const Any& lhs, const Any& rhs)
    {
        void* lhs_storage = lhs.storage;
        void* rhs_storage = rhs.storage;        
        return lhs.policy == rhs.policy and
            lhs.policy->equals(&lhs_storage, &rhs_storage);
    }

    inline bool operator!=(const Any& lhs, const Any& rhs)
    {        
        return !(lhs == rhs);
    }

    struct Any::Empty
    {
        bool operator==(const Empty& other) const
        {
            return true;
        }
    };

    template <typename T>
    inline Any erase_type(const T& v)
    {
        return Any(v);
    }

    template <typename T>
    inline T recall_type(const Any& any)
    {
        return any.as<T>();
    }

}

#endif  //_ANY_H_