components.hpp

Go to the documentation of this file.

//=======================================================================
// Copyright (c) 2013 Piotr Wygocki
//
// Distributed under the Boost Software License, Version 1.0. (See
// accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//=======================================================================
#ifndef PAAL_COMPONENTS_HPP
#define PAAL_COMPONENTS_HPP

#include "paal/data_structures/components/types_vector.hpp"

#include <utility>
#include <iostream>

namespace paal {
namespace data_structures {

template <typename Name, typename Default> struct NameWithDefault;

struct copy_tag {};

// This namespace block contains implementation of the main class
// components<Names,Types> and needed meta functions
namespace detail {

template <typename T> struct wrap_to_constructable {
    typedef T type;
};


template <typename Name, typename Names, typename Types> struct type_for_name {
    typedef typename remove_n_first<1, Names>::type NewNames;
    typedef typename remove_n_first<1, Types>::type NewTypes;
    typedef typename type_for_name<Name, NewNames, NewTypes>::type type;
};

template <typename Name, typename Type, typename... NamesRest,
          typename... TypesRest>
struct type_for_name<Name, TypesVector<Name, NamesRest...>,
                     TypesVector<Type, TypesRest...>> {
    typedef Type type;
};


template <typename T, typename Name> class has_template_get {
  private:
    template <typename C>
    static char f(wrap_to_constructable<decltype(
        std::declval<const C>().template get<Name>())(C::*)() const> *);

    template <typename C> static long f(...);

  public:
    static const bool value =
        (sizeof(f<typename std::decay<T>::type>(nullptr)) == sizeof(char));
};

struct movable_tag {};
struct Notmovable_tag {};

// declaration of main class components
template <typename Names, typename Types> class components;

// specialization for empty Names list
template <> class components<TypesVector<>, TypesVector<>> {
  public:
    void get() const;
    void call() const;
    void call2() const;

    template <typename... Unused> components(const Unused &...) {}
};

// specialization for nonempty types list
// class keeps first component as data memer
// rest of the components are kept in superclass.
template <typename Name, typename Type, typename... NamesRest,
          typename... TypesRest>
class components<TypesVector<Name, NamesRest...>,
                 TypesVector<Type, TypesRest...>> : public components<
    TypesVector<NamesRest...>, TypesVector<TypesRest...>> {
    typedef components<TypesVector<NamesRest...>, TypesVector<TypesRest...>>
        base;
    typedef TypesVector<Name, NamesRest...> Names;
    typedef TypesVector<Type, TypesRest...> Types;

    template <typename ComponentName>
    using is_my_name =
        typename std::enable_if<std::is_same<ComponentName, Name>::value>::type;

  public:
    using base::get;

    // we do not use  = default, cause we'd like to value initialize POD's.
    components() : base{}, m_component{} {};

    //  copy constructor
    components(components const & other)
        : base(static_cast<base const &>(other)), m_component(other.get<Name>()) {}

    // doesn't work on clang 3.2 // change in the standard and visual studio 2015 preview
    // components(components &) = default;
    // constructor taking nonconst lvalue reference
    components(components &other)
        : base(static_cast<base &>(other)), m_component(other.get<Name>()) {}

    //  move constructor
    components(components &&) = default;

    // assignment operator
    components &operator=(components const & other) {

        static_cast<base &>(*this) = static_cast<base &>(other);
        m_component = other.get<Name>();
        return *this;
    }

    // doesn't work on clang 3.2 // change in the standard
    // components& operator=(components &) = default;
    // assignment operator taking nonconst lvalue reference
    components &operator=(components &other) {
        static_cast<base &>(*this) = static_cast<base &>(other);
        m_component = other.get<Name>();
        return *this;
    }

    // default move operator
    components &operator=(components &&) = default;

    template <typename T, typename... TypesPrefix>
    components(T &&t, TypesPrefix &&... types)
        : base(std::forward<TypesPrefix>(types)...),
          m_component(std::forward<T>(t)) {}

    //     copy constructor takes class wich has get<Name> member function
    //     the get<> function dosn't have to be available for all names.
    //     @param copy_tag is helps identify  this constructor
    template <typename Comps>
    components(const Comps &comps, copy_tag)
        : components(comps, Notmovable_tag()) {}

    //   move  constructor takes class wich has get<Name> member function
    //     the get<> function dosn't have to be available for all names.
    //     In this version each of the components taken from comps
    //     is going to be moved.
    //     @param copy_tag is helps identify  this constructor
    template <typename Comps>
    components(Comps &&comps, copy_tag)
        : components(comps, movable_tag()) {}

    template <typename ComponentName, typename = is_my_name<ComponentName>>
    Type &get(wrap_to_constructable<Name> dummy =
                  wrap_to_constructable<Name>()) {
        return m_component;
    }

    template <typename ComponentName, typename = is_my_name<ComponentName>>
    const Type &get(wrap_to_constructable<Name> dummy =
                        wrap_to_constructable<Name>()) const {
        return m_component;
    }

    template <typename ComponentName, typename... Args>
    auto call(Args &&... args)->decltype(std::declval<
        typename type_for_name<ComponentName, Names, Types>::type>()(
        std::forward<Args>(args)...)) {
        return this->template get<ComponentName>()(std::forward<Args>(args)...);
    }

    template <typename ComponentName, typename... Args>
    auto call(Args &&... args) const->decltype(std::declval<
        const typename type_for_name<ComponentName, Names, Types>::type>()(
        std::forward<Args>(args)...)) {
        return this->template get<ComponentName>()(std::forward<Args>(args)...);
    }

    template <typename ComponentName>
    void
    set(const typename type_for_name<ComponentName, Names, Types>::type comp) {
        this->get<ComponentName>() = std::move(comp);
    }

    template <typename... NamesSubset, typename... SomeTypes>
    static components<Names, Types>
        // make(SomeTypes... types) {
        //  static_assert(sizeof...(NamesSubset) == sizeof...(SomeTypes),
        // "Incorrect number of arguments.");
        // return components<Names,
        // Types>(components<TypesVector<NamesSubset...>,
        // TypesVector<SomeTypes...>>(std::move(types)...), copy_tag());
        make(SomeTypes &&... types) {
        static_assert(sizeof...(NamesSubset) == sizeof...(SomeTypes),
                      "Incorrect number of arguments.");
        components<TypesVector<NamesSubset...>, TypesVector<SomeTypes...>>
            comps(std::forward<SomeTypes>(types)...);
        return components<Names, Types>(std::move(comps), copy_tag());
    }

  protected:

    // object is moved if move = true, otherwise passed by reference
    template <bool move, typename A> A move_or_pass_reference(const A &a) {
        return std::move(a);
    }

    // const reference case
    template <bool move, typename A,
              typename = typename std::enable_if<!move>::type>
    const A &move_or_pass_reference(const A &a) {
        return a;
    }

    // nonconst reference case
    template <bool move, typename A,
              typename = typename std::enable_if<!move>::type>
    A &move_or_pass_reference(A &a) {
        return a;
    }

    // All of this constructor takes Comps as r-value reference,
    // because they have to win specialization race with normal constructor.

    // case: movable object, has the appropriate get member function
    template <typename Comps,
              typename dummy = typename std::enable_if<
                  has_template_get<Comps, Name>::value, int>::type>
    components(Comps &&comps, movable_tag m, dummy d = dummy())
        : base(std::forward<Comps>(comps), std::move(m)),
          // if Type is not reference type, comps.get<Name>() is moved otherwise
          // reference is  passed
          m_component(
              move_or_pass_reference<!std::is_lvalue_reference<Type>::value>(
                  comps.template get<Name>())) {}

    // case: movable object, does not have the appropriate get member function
    template <typename Comps, typename dummy = typename std::enable_if<
                                  !has_template_get<Comps, Name>::value>::type>
    components(Comps &&comps, movable_tag m)
        : base(std::forward<Comps>(comps), std::move(m)) {}

    // case: not movable object, has the appropriate get member function
    template <typename Comps,
              typename dummy = typename std::enable_if<
                  has_template_get<Comps, Name>::value, int>::type>
    components(Comps &&comps, Notmovable_tag m, dummy d = dummy())
        : base(std::forward<Comps>(comps), std::move(m)),
          m_component(comps.template get<Name>()) {}

    // case: not movable object, does not  have the appropriate get member
    // function
    template <typename Comps, typename dummy = typename std::enable_if<
                                  !has_template_get<Comps, Name>::value>::type>
    components(Comps &&comps, Notmovable_tag m)
        : base(std::forward<Comps>(comps), std::move(m)) {}

  private:
    Type m_component;
};
} // detail

//This namespace contains class which sets all defaults and all needed meta functions.

namespace detail {

template <typename Names, typename Defaults, typename TypesPrefix>
class set_defaults {
    static const int N = size<Names>::value;
    static const int TYPES_NR = size<TypesPrefix>::value;
    static_assert(TYPES_NR <= N, "Incrrect number of parameters");

    static const int DEFAULTS_NR = size<Defaults>::value;
    static_assert(DEFAULTS_NR + TYPES_NR >= N, "Incrrect number of parameters");

    typedef typename remove_n_first<DEFAULTS_NR + TYPES_NR - N, Defaults>::type
        NeededDefaults;

    typedef typename join<TypesPrefix, NeededDefaults>::type Types;

  public:
    typedef detail::components<Names, Types> type;
};
} // detail

//Here are some meta functions, to parse the arguments
namespace detail {
template <typename T> struct get_name {
    typedef T type;
};

template <typename Name, typename Default>
struct get_name<NameWithDefault<Name, Default>> {
    typedef Name type;
};

struct push_back_name {
    template <typename Vector, typename NameWithDefault> struct apply {
        typedef typename push_back<
            Vector, typename get_name<NameWithDefault>::type>::type type;
    };
};

/*
 * @brief Meta function takes NameWithDefault and Vector
 *        the result is new vector with new Name appended Default
 */
struct push_back_default {
    //  This case applies to when NameWithDefault is only name
    template <typename Vector, typename Name> struct apply {
        typedef Vector type;
    };

    // This case applies when NameWithDefault contains Default
    template <typename Vector, typename Name, typename Default>
    struct apply<Vector, NameWithDefault<Name, Default>> {
        typedef typename push_back<Vector, Default>::type type;
    };
};
} // detail

template <typename... ComponentNamesWithDefaults> class components {
    typedef TypesVector<ComponentNamesWithDefaults...> NamesWithDefaults;

    typedef typename fold<NamesWithDefaults, TypesVector<>,
                          detail::push_back_name>::type Names;

    typedef typename fold<NamesWithDefaults, TypesVector<>,
                          detail::push_back_default>::type Defaults;

    template <class T> struct special_decay {
        using type = typename std::decay<T>::type;
    };

    template <class T> struct special_decay<std::reference_wrapper<T>> {
        using type = T &;
    };

    template <class T> using special_decay_t = typename special_decay<T>::type;

  public:
    template <typename... ComponentTypes>
    using type = typename detail::set_defaults<
        Names, Defaults, TypesVector<ComponentTypes...>>::type;

    template <typename... components>
    static type<special_decay_t<components>...>
    make_components(components &&... comps) {
        return type<special_decay_t<components>...>(
            std::forward<components>(comps)...);
    }

  private:
    // in this block we check if the defaults are on the last positions in the
    // NamesWithDefaults
    static const int N = size<NamesWithDefaults>::value;
    static const int DEFAULTS_NR = size<Defaults>::value;
    typedef typename remove_n_first<N - DEFAULTS_NR, NamesWithDefaults>::type
        DefaultPart;
    typedef typename fold<DefaultPart, TypesVector<>,
                          detail::push_back_default>::type DefaultsTest;
    static_assert(std::is_same<DefaultsTest, Defaults>::value,
                  "Defaults values could be only on subsequent number of last "
                  "parameters");
};

} 
} 
#endif // PAAL_COMPONENTS_HPP