source: finroc_plugins_composite_ports/internal/type_traits.h @ 28:0d9e9fd957de

//
// You received this file as part of Finroc
// A framework for intelligent robot control
//
// Copyright (C) Finroc GbR (finroc.org)
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// This program 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 General Public License for more details.
//
// You should have received a copy of the GNU General Public License along
// with this program; if not, write to the Free Software Foundation, Inc.,
// 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
//
//----------------------------------------------------------------------
/*!\file    plugins/composite_ports/internal/type_traits.h
 *
 * \author  Max Reichardt
 *
 * \date    2020-02-11
 *
 * Type traits with respect to port types in particular
 *
 */
//----------------------------------------------------------------------
#ifndef __plugins__structure__internal__type_traits_h__
#define __plugins__structure__internal__type_traits_h__

//----------------------------------------------------------------------
// External includes (system with <>, local with "")
//----------------------------------------------------------------------
#include "plugins/data_ports/tGenericPort.h"
#include "plugins/data_ports/tInputPort.h"
#include "plugins/data_ports/tOutputPort.h"
#include "plugins/data_ports/tProxyPort.h"
#include "plugins/parameters/tParameter.h"

#ifdef _LIB_FINROC_PLUGINS_RPC_PORTS_PRESENT_
#include "plugins/rpc_ports/tServerPort.h"
#include "plugins/rpc_ports/tClientPort.h"
#include "plugins/rpc_ports/tProxyPort.h"
#endif

//----------------------------------------------------------------------
// Internal includes with ""
//----------------------------------------------------------------------

//----------------------------------------------------------------------
// Namespace declaration
//----------------------------------------------------------------------
namespace finroc
{

//----------------------------------------------------------------------
// Forward declarations / typedefs / enums
//----------------------------------------------------------------------

namespace rpc_ports
{
class tRPCInterface;
template <typename T>
class tServerPort;
template <typename T>
class tClientPort;
template <typename T, bool SERVER_PORT>
class tProxyPort;
}

namespace structure
{
class tConveniencePortBase;
template <typename TPort>
class tBasicConveniencePort;
}

namespace composite_ports
{
namespace internal
{

enum tPortTypeRelation
{
  ePTR_INPUT,
  ePTR_OUTPUT,
  ePTR_PARAMETER,
  ePTR_COUNTER_PART,
  ePTR_COUNTER_PART_PARAMETER_IF_INPUT,
  ePTR_SERVER_IF_INPUT,
  ePTR_CLIENT_IF_INPUT,
  ePTR_DIMENSION
};

template <int Tprimary_interface_relations, template <typename> class TPortType, typename T, bool Trpc, bool Tdirection_specified>
class tGenericPortType;

//----------------------------------------------------------------------
// Function declarations
//----------------------------------------------------------------------

class tTestType : public rrlib::serialization::tMemoryBuffer
#ifdef _LIB_FINROC_PLUGINS_RPC_PORTS_PRESENT_
  , public rpc_ports::tRPCInterface
#endif
{};

template <template <typename> class TPortType>
struct IsRPCPort
{
  enum { value = (!std::is_base_of<data_ports::tPort<tTestType>, TPortType<tTestType>>::value) && (!std::is_base_of<parameters::tParameter<tTestType>, TPortType<tTestType>>::value) };
};

template <template <typename> class TPortType>
struct IsConveniencePort
{
  enum { value = std::is_base_of<structure::tConveniencePortBase, TPortType<tTestType>>::value };
};

template <template <typename> class TPortType, bool Trpc = IsRPCPort<TPortType>::value>
struct IsOutputPort
{
  enum { value = std::is_base_of<data_ports::tOutputPort<double>, TPortType<double>>::value  ||
         std::is_base_of<data_ports::tProxyPort<double, true>, TPortType<double>>::value
       };
};
template <template <typename> class TPortType>
struct IsOutputPort<TPortType, true>
{
  enum { value = std::is_base_of<rpc_ports::tClientPort<tTestType>, TPortType<tTestType>>::value ||
         std::is_base_of<rpc_ports::tProxyPort<tTestType, false>, TPortType<tTestType>>::value
       };
};

template <template <typename> class TPortType, bool Trpc = IsRPCPort<TPortType>::value>
struct IsInputPort
{
  enum { value = std::is_base_of<data_ports::tInputPort<double>, TPortType<double>>::value ||
         std::is_base_of<data_ports::tProxyPort<double, false>, TPortType<double>>::value ||
         std::is_base_of<parameters::tParameter<double>, TPortType<double>>::value
       };
};
template <template <typename> class TPortType>
struct IsInputPort<TPortType, true>
{
  enum { value = std::is_base_of<rpc_ports::tServerPort<tTestType>, TPortType<tTestType>>::value ||
         std::is_base_of<rpc_ports::tProxyPort<tTestType, true>, TPortType<tTestType>>::value
       };
};


template <template <typename> class TPort, bool Trpc = IsRPCPort<TPort>::value>
struct MakeInputPortImplementation
{
  template <typename T>
  using base_type = typename std::conditional < std::is_base_of<data_ports::tProxyPort<tTestType, false>, TPort<tTestType>>::value || std::is_base_of<data_ports::tProxyPort<tTestType, true>, TPort<tTestType>>::value, data_ports::tProxyPort<T, false>, data_ports::tInputPort<T >>::type;

  template <typename T>
  using type = typename std::conditional<IsConveniencePort<TPort>::value, structure::tBasicConveniencePort<base_type<T>>, base_type<T>>::type;
};
template <template <typename> class TPort>
struct MakeInputPortImplementation<TPort, true>
{
  template <typename T>
  using base_type = typename std::conditional < std::is_base_of<rpc_ports::tServerPort<tTestType>, TPort<tTestType>>::value || std::is_base_of<rpc_ports::tClientPort<tTestType>, TPort<tTestType>>::value, rpc_ports::tServerPort<T>, rpc_ports::tProxyPort<T, true >>::type;

  template <typename T>
  using type = typename std::conditional<IsConveniencePort<TPort>::value, structure::tBasicConveniencePort<base_type<T>>, base_type<T>>::type;
};
template <template <typename> class TPort>
using MakeInputPort = MakeInputPortImplementation<TPort>;

template <template <typename> class TPort, bool Trpc = IsRPCPort<TPort>::value>
struct MakeOutputPortImplementation
{
  template <typename T>
  using base_type = typename std::conditional < std::is_base_of<data_ports::tProxyPort<tTestType, false>, TPort<tTestType>>::value || std::is_base_of<data_ports::tProxyPort<tTestType, true>, TPort<tTestType>>::value, data_ports::tProxyPort<T, true>, data_ports::tOutputPort<T >>::type;

  template <typename T>
  using type = typename std::conditional<IsConveniencePort<TPort>::value, structure::tBasicConveniencePort<base_type<T>>, base_type<T>>::type;
};
template <template <typename> class TPort>
struct MakeOutputPortImplementation<TPort, true>
{
  template <typename T>
  using base_type = typename std::conditional < std::is_base_of<rpc_ports::tClientPort<tTestType>, TPort<tTestType>>::value || std::is_base_of<rpc_ports::tClientPort<tTestType>, TPort<tTestType>>::value, rpc_ports::tClientPort<T>, rpc_ports::tProxyPort<T, false >>::type;

  template <typename T>
  using type = typename std::conditional<IsConveniencePort<TPort>::value, structure::tBasicConveniencePort<base_type<T>>, base_type<T>>::type;
};
template <template <typename> class TPort>
using MakeOutputPort = MakeOutputPortImplementation<TPort>;

template <template <typename> class TPort>
struct MakeParameter
{
  template <typename T>
  using type = typename std::conditional<IsConveniencePort<TPort>::value, structure::tBasicConveniencePort<parameters::tParameter<T>>, parameters::tParameter<T>>::type;
};

template <template <typename> class TPort, bool Tpossibly_parameter, bool Tinput = IsInputPort<TPort>::value, bool Toutput = IsOutputPort<TPort>::value>
struct MakeCounterDirectionPort
{
  template <typename T>
  using type = data_ports::tPort<T>;
};
template <template <typename> class TPort, bool Tpossibly_parameter>
struct MakeCounterDirectionPort<TPort, Tpossibly_parameter, true, false>
{
  template <typename T>
  using type = typename MakeOutputPort<TPort>::template type<T>;
};
template <template <typename> class TPort>
struct MakeCounterDirectionPort<TPort, false, false, true>
{
  template <typename T>
  using type = typename MakeInputPort<TPort>::template type<T>;
};
template <template <typename> class TPort>
struct MakeCounterDirectionPort<TPort, true, false, true> : MakeParameter<TPort>
{
};
template <template <typename> class TPort>
using MakeCounterPart = MakeCounterDirectionPort<TPort, false>;
template <template <typename> class TPort>
using MakeCounterPartParameterIfInput = MakeCounterDirectionPort<TPort, true>;

template <template <typename> class TPort, bool TServer, bool TClient>
struct MakeRPCPort
{
  template <typename T>
  using type = core::tPortWrapperBase;
};
template <template <typename> class TPort>
struct MakeRPCPort<TPort, false, true>
{
  template <typename T>
  using base_type = typename std::conditional < std::is_base_of<data_ports::tProxyPort<tTestType, false>, TPort<tTestType>>::value || std::is_base_of<data_ports::tProxyPort<tTestType, true>, TPort<tTestType>>::value, rpc_ports::tProxyPort<T, false>, rpc_ports::tClientPort<T >>::type;

  template <typename T>
  using type = typename std::conditional<IsConveniencePort<TPort>::value, structure::tBasicConveniencePort<base_type<T>>, base_type<T>>::type;
};
template <template <typename> class TPort>
struct MakeRPCPort<TPort, true, false>
{
  template <typename T>
  using base_type = typename std::conditional < std::is_base_of<data_ports::tProxyPort<tTestType, false>, TPort<tTestType>>::value || std::is_base_of<data_ports::tProxyPort<tTestType, true>, TPort<tTestType>>::value, rpc_ports::tProxyPort<T, true>, rpc_ports::tServerPort<T >>::type;

  template <typename T>
  using type = typename std::conditional<IsConveniencePort<TPort>::value, structure::tBasicConveniencePort<base_type<T>>, base_type<T>>::type;
};

template <template <typename> class TPort>
using MakeServerIfInput = MakeRPCPort<TPort, IsInputPort<TPort>::value, IsOutputPort<TPort>::value>;
template <template <typename> class TPort>
using MakeClientIfInput = MakeRPCPort<TPort, IsOutputPort<TPort>::value, IsInputPort<TPort>::value>;


template <typename TPort>
struct GetRelationId
{
  enum { value = 0 };
};
template <int Tprimary_interface_relations, template <typename> class TPortType, typename T, bool Trpc, bool Tdirection_specified>
struct GetRelationId<tGenericPortType<Tprimary_interface_relations, TPortType, T, Trpc, Tdirection_specified>>
{
  enum { value = Tprimary_interface_relations };
};

template <int Trelation_id, template <typename> class TReferencePort, template <template <typename> class> class TBasePort>
struct PrimaryPortRelation
{
  template <typename T>
  using base_port = typename TBasePort<TReferencePort>::template type<T>;

  template <typename T>
  using type = tGenericPortType < GetRelationId<TReferencePort<double>>::value * 256 + Trelation_id, base_port, T, IsRPCPort<base_port>::value, IsInputPort<base_port>::value || IsOutputPort<base_port>::value >;
};


//----------------------------------------------------------------------
// End of namespace declaration
//----------------------------------------------------------------------
}
}
}


#endif