source: finroc_plugins_composite_ports/tInterface.h @ 8:1cdb6fac7784

//
// 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/tInterface.h
 *
 * \author  Max Reichardt
 *
 * \date    2020-01-02
 *
 * \brief   Contains tInterface
 *
 * \b tInterface
 *
 * Base class for port composite interfaces (interfaces consisting of a set of ports)
 *
 */
//----------------------------------------------------------------------
#ifndef __plugins__structure__tInterface_h__
#define __plugins__structure__tInterface_h__

//----------------------------------------------------------------------
// External includes (system with <>, local with "")
//----------------------------------------------------------------------
#include "rrlib/util/tTypeList.h"
#include "core/port/tPortGroup.h"

//----------------------------------------------------------------------
// Internal includes with ""
//----------------------------------------------------------------------
#include "plugins/composite_ports/internal/type_traits.h"
#include "plugins/composite_ports/tInterfaceType.h"
#include "plugins/composite_ports/internal/tGenericPortType.h"

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

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

namespace structure
{
class tComponent;
}

namespace composite_ports
{

namespace port_relation
{

template <template <typename T> class TPortType>
using tInput = typename internal::PrimaryPortRelation<internal::tPortTypeRelation::ePTR_INPUT, TPortType, internal::MakeInputPort>;
template <template <typename> class TPortType>
using tOutput = typename internal::PrimaryPortRelation<internal::tPortTypeRelation::ePTR_OUTPUT, TPortType, internal::MakeOutputPort>;
template <template <typename> class TPortType>
using tParameter = typename internal::PrimaryPortRelation<internal::tPortTypeRelation::ePTR_PARAMETER, TPortType, internal::MakeParameter>;
template <template <typename> class TPortType>
using tCounterPart = typename internal::PrimaryPortRelation<internal::tPortTypeRelation::ePTR_COUNTER_PART, TPortType, internal::MakeCounterPart>;
template <template <typename> class TPortType>
using tCounterPartParameterInputs = typename internal::PrimaryPortRelation<internal::tPortTypeRelation::ePTR_COUNTER_PART_PARAMETER_IF_INPUT, TPortType, internal::MakeCounterPartParameterIfInput>; //::template base_port;

}

//----------------------------------------------------------------------
// Class declaration
//----------------------------------------------------------------------
//! Port composite interface template base class
/*!
 * Base class for port composite interfaces (interfaces consisting of a set of ports)
 */
template <template <typename> class TPrimaryPort>
class tInterface : public tInterfaceBase
{
  enum { cCONVENIENCE_PORT = std::is_base_of<structure::tConveniencePortBase, TPrimaryPort<double>>::value };
  //enum { cGENERIC_INSTANCE = std::is_same<TPrimaryPort<double>, internal::tGenericPortType<0, double, false>>::value };
  enum { cPRIMARY_RELATION_ID = internal::GetRelationId<TPrimaryPort<double>>::value };

//----------------------------------------------------------------------
// Public methods and typedefs
//----------------------------------------------------------------------
public:

  typedef typename std::conditional<cCONVENIENCE_PORT, structure::tComponent*, core::tPortGroup*>::type tParent;

//----------------------------------------------------------------------
// Protected methods
//----------------------------------------------------------------------
protected:

  tInterface() :
    tInterfaceBase(nullptr)
  {}

  /*!
   * \param interface_type Interface type
   * \param parent Parent (component for convenience ports as template arguments - and port group(s) otherwise)
   * \param name Name of interface (must be unique in parent)
   * \param port_type_relation If this port composite interface has multiple data port types, specifies how they are typically related (relevant for generic instantiation)
   * \param custom_connect_function Custom connect function for this interface
   */
  tInterface(const rrlib::rtti::tType& interface_type, tParent parent, const std::string& name, const tConnectFunction& custom_connect_function = tConnectFunction()) :
    tInterfaceBase(new tInterfaceBase::tBackend(interface_type, parent, GetPrimaryPortTypeParent(parent), cPRIMARY_RELATION_ID, name, cCONVENIENCE_PORT, custom_connect_function, GetDefaultCreateMissingInterfaceFunction(parent)))
  {
  }

  /*!
   * (Constructor for other port composite interface as parent)
   *
   * \param interface_type Interface type
   * \param parent Parent port composite interface
   * \param name Name of interface (must be unique in parent)
   * \param custom_connect_function Custom connect function for this interface
   */
  template <typename TParent, bool Tenable = std::is_base_of<tInterfaceBase, typename std::decay<TParent>::type>::value>
  tInterface(typename std::enable_if<Tenable, const rrlib::rtti::tType&>::type interface_type, TParent* parent, const std::string& name, const tConnectFunction& custom_connect_function = tConnectFunction()) :
    tInterfaceBase(parent->Backend() ? new tInterfaceBase::tBackend(interface_type, cCONVENIENCE_PORT ? parent->ParentComponent() : parent->Backend(), parent->Backend()->GetBackend(cPRIMARY_RELATION_ID), cPRIMARY_RELATION_ID, name, cCONVENIENCE_PORT, custom_connect_function) : nullptr)
  {
  }

  /*! Helper constructor to extract interface type */
  tInterface(const rrlib::rtti::tType& interface_type, tInterfaceTypeData* parent, const std::string& name, const tConnectFunction& custom_connect_function = tConnectFunction()) :
    tInterfaceBase()
  {
    parent->type = interface_type;
  }

//----------------------------------------------------------------------
// Private fields and methods
//----------------------------------------------------------------------
private:

  template <template <typename> class UPrimaryPort>
  friend class tInterface;

  template <int Tconvenience_port = cCONVENIENCE_PORT>
  static core::tFrameworkElement* GetPrimaryPortTypeParent(typename std::enable_if<Tconvenience_port, tParent>::type parent)
  {
    return &TPrimaryPort<double>::GetParentInterface(static_cast<typename TPrimaryPort<double>::tComponent&>(*parent));
  }

  static core::tFrameworkElement* GetPrimaryPortTypeParent(core::tPortGroup* parent)
  {
    return parent;
  }

  template <int Tconvenience_port = cCONVENIENCE_PORT>
  static constexpr tCreateMissingComponentInterfaceFunction GetDefaultCreateMissingInterfaceFunction(typename std::enable_if<Tconvenience_port, tParent>::type parent)
  {
    return tInterfaceBase::GetDefaultCreateMissingInterfaceFunction<typename TPrimaryPort<double>::tComponent>();
  }
  static constexpr tCreateMissingComponentInterfaceFunction GetDefaultCreateMissingInterfaceFunction(core::tPortGroup* parent)
  {
    return nullptr;
  }

};

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


#endif