SingleDispatcher.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_SINGLEDISPATCHER_HPP
#define AURORA_SINGLEDISPATCHER_HPP

#include <Aurora/Dispatch/DispatchTraits.hpp>
#include <Aurora/Tools/NonCopyable.hpp>
#include <Aurora/Tools/Exceptions.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, 1>>
class SingleDispatcher : private NonCopyable
{
    // ---------------------------------------------------------------------------------------------------------------------------
    // Public types
    public:
        typedef typename FunctionResult<Signature>::Type        Result;

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

        typedef typename FunctionParam<Signature, 1>::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.");


    // ---------------------------------------------------------------------------------------------------------------------------
    // Public member functions
    public:
                                    SingleDispatcher();

                                    SingleDispatcher(SingleDispatcher&& source);

        SingleDispatcher&           operator= (SingleDispatcher&& source);

                                    ~SingleDispatcher();

        template <typename Id, typename Fn>
        void                        bind(const Id& identifier, Fn function);

        Result                      call(Parameter arg) const;

        Result                      call(Parameter arg, UserData data) const;

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


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


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


} // namespace aurora

#include <Aurora/Dispatch/Detail/SingleDispatcher.inl>
#endif // AURORA_SINGLEDISPATCHER_HPP