DoubleDispatcher.hpp

Go to the documentation of this file.

//
// Aurora C++ Library
// Copyright (c) 2012-2016 Jan Haller
//
// This software is provided 'as-is', without any express or implied
// warranty. In no event will the authors be held liable for any damages
// arising from the use of this software.
//
// Permission is granted to anyone to use this software for any purpose,
// including commercial applications, and to alter it and redistribute it
// freely, subject to the following restrictions:
//
// 1. The origin of this software must not be misrepresented; you must not
//    claim that you wrote the original software. If you use this software
//    in a product, an acknowledgment in the product documentation would be
//    appreciated but is not required.
//
// 2. Altered source versions must be plainly marked as such, and must not be
//    misrepresented as being the original software.
//
// 3. This notice may not be removed or altered from any source distribution.
//


#ifndef AURORA_DOUBLEDISPATCHER_HPP
#define AURORA_DOUBLEDISPATCHER_HPP

#include <Aurora/Dispatch/DispatchTraits.hpp>
#include <Aurora/Tools/NonCopyable.hpp>
#include <Aurora/Tools/Exceptions.hpp>
#include <Aurora/Tools/Hash.hpp>
#include <Aurora/Meta/Templates.hpp>
#include <Aurora/Config.hpp>

#include <unordered_map>
#include <functional>
#include <algorithm>
#include <cassert>


namespace aurora
{


template <typename Signature, class Traits = RttiDispatchTraits<Signature, 2>>
class DoubleDispatcher : private NonCopyable
{
    // ---------------------------------------------------------------------------------------------------------------------------
    // Public types
    public:
        typedef typename FunctionResult<Signature>::Type        Result;

        typedef typename FunctionParam<Signature, 0>::Type      Parameter;

        typedef typename FunctionParam<Signature, 2>::Type      UserData;


    // ---------------------------------------------------------------------------------------------------------------------------
    // Static assertions

    // Make sure that B is either T* or T&
    static_assert(std::is_pointer<Parameter>::value || std::is_lvalue_reference<Parameter>::value,
        "Function parameter must be a pointer or reference.");

    // For signature R(X, Y), ensure that X == Y
    static_assert(std::is_same<typename FunctionParam<Signature, 0>::Type, typename FunctionParam<Signature, 1>::Type>::value,
        "The two function parameters must have the same type.");


    // ---------------------------------------------------------------------------------------------------------------------------
    // Public member functions
    public:
        explicit                    DoubleDispatcher(bool symmetric = true);

                                    DoubleDispatcher(DoubleDispatcher&& source);

        DoubleDispatcher&           operator= (DoubleDispatcher&& source);

                                    ~DoubleDispatcher();

        template <typename Id1, typename Id2, typename Fn>
        void                        bind(const Id1& identifier1, const Id2& identifier2, Fn function);

        Result                      call(Parameter arg1, Parameter arg2) const;

        Result                      call(Parameter arg1, Parameter arg2, UserData data) const;

        void                        fallback(std::function<Signature> function);


    // ---------------------------------------------------------------------------------------------------------------------------
    // Private types
    private:
        typedef typename Traits::Key                    SingleKey;
        typedef std::function<Signature>                BaseFunction;

        struct Key
        {
                                            Key(const SingleKey& key1, const SingleKey& key2, bool swapped);
            bool                            operator== (const Key& rhs) const;

            std::pair<SingleKey, SingleKey> keyPair;
            bool                            swapped;
        };

        struct Hasher
        {
            std::size_t operator() (const Key& k) const;
        };

        typedef std::unordered_map<Key, BaseFunction, Hasher>       FnMap;


    // ---------------------------------------------------------------------------------------------------------------------------
    // Private member functions
    private:
        // Makes sure that the keys are sorted in case we use symmetric argument dispatching.
        Key                         makeKey(SingleKey key1, SingleKey key2) const;


    // ---------------------------------------------------------------------------------------------------------------------------
    // Private variables
    private:
        FnMap                       mMap;
        BaseFunction                mFallback;
        bool                        mSymmetric;
};


} // namespace aurora

#include <Aurora/Dispatch/Detail/DoubleDispatcher.inl>
#endif // AURORA_DOUBLEDISPATCHER_HPP