source: finroc_plugins_composite_ports/tInterfaceBase.cpp @ 36:ea39cd84ad73

//
// 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/tInterfaceBase.cpp
 *
 * \author  Max Reichardt
 *
 * \date    2020-01-14
 *
 */
//----------------------------------------------------------------------
#include "plugins/composite_ports/tInterfaceBase.h"

//----------------------------------------------------------------------
// External includes (system with <>, local with "")
//----------------------------------------------------------------------
#include "core/tFrameworkElementTags.h"
#include "core/tRuntimeEnvironment.h"
#include "rrlib/util/string.h"
#include "rrlib/rtti_conversion/tStaticCastOperation.h"

//----------------------------------------------------------------------
// Internal includes with ""
//----------------------------------------------------------------------
#include "plugins/composite_ports/internal/tInterfaceTypeInfo.h"
#include "plugins/composite_ports/internal/type_traits.h"
#include "plugins/composite_ports/defined_conversions.h"
#include "plugins/composite_ports/tInterfaceModifier.h"
#include "plugins/composite_ports/interface_types.h"
#include "plugins/composite_ports/internal/tPortSelectConversionOperation.h"
#include "plugins/composite_ports/utils/tPortSelector.h"

//----------------------------------------------------------------------
// Debugging
//----------------------------------------------------------------------
#include <cassert>

//----------------------------------------------------------------------
// Namespace usage
//----------------------------------------------------------------------

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

//----------------------------------------------------------------------
// Forward declarations / typedefs / enums
//----------------------------------------------------------------------
typedef core::tFrameworkElementFlag tFlag;

//----------------------------------------------------------------------
// Const values
//----------------------------------------------------------------------
const std::string cINTERFACE_TAG_SINGLE_BACKEND_INSTANTIATION = "finroc.composite_ports.single_backend_instantiation";

//----------------------------------------------------------------------
// Implementation
//----------------------------------------------------------------------

namespace
{

const tInterfaceModifier::tImplementation cMODIFIER_DEFAULT_IMPLEMENTATION;

const core::tFrameworkElement* GetAggregator(const core::tFrameworkElement& element, core::tFrameworkElementFlags* extend_with_default_ports_flags = nullptr)
{
  if (element.GetFlag(tFlag::EDGE_AGGREGATOR) && (!element.IsPort()))
  {
    if (element.GetFlag(tFlag::INTERFACE) && extend_with_default_ports_flags)
    {
      (*extend_with_default_ports_flags) |= static_cast<const core::tPortGroup&>(element).GetDefaultPortFlags();
      if (element.GetFlag(tFlag::SENSOR_DATA))
      {
        (*extend_with_default_ports_flags) |= tFlag::SENSOR_DATA;
      }
      if (element.GetFlag(tFlag::CONTROLLER_DATA))
      {
        (*extend_with_default_ports_flags) |= tFlag::CONTROLLER_DATA;
      }
      if (element.GetFlag(tFlag::INTERFACE_FOR_INPUTS) || element.GetFlag(tFlag::PARAMETER_INTERFACE))
      {
        (*extend_with_default_ports_flags) |= data_ports::cDEFAULT_INPUT_PORT_FLAGS;
      }
      if (element.GetFlag(tFlag::INTERFACE_FOR_OUTPUTS))
      {
        (*extend_with_default_ports_flags) |= data_ports::cDEFAULT_OUTPUT_PORT_FLAGS;
      }
      if (element.GetFlag(tFlag::PROXY_INTERFACE))
      {
        (*extend_with_default_ports_flags) |= tFlag::EMITS_DATA | tFlag::ACCEPTS_DATA;
      }
      if (element.GetFlag(tFlag::INTERFACE_FOR_RPC_PORTS))
      {
        (*extend_with_default_ports_flags) |= tFlag::EMITS_DATA | tFlag::ACCEPTS_DATA;
      }
    }
    return &element;
  }
  return element.GetParent() ? GetAggregator(*element.GetParent(), extend_with_default_ports_flags) : nullptr;
}

tInterfaceModifier* GetModifier(const core::tFrameworkElement& any_element)
{
  auto current_element = &any_element;
  do
  {
    auto annotation = current_element->GetAnnotation<tInterfaceModifier>();
    if (annotation)
    {
      return annotation;
    }
    current_element = current_element->GetParent();
  }
  while (current_element);
  return nullptr;
}

tInterfaceBase::tPrimaryPortType ModifierDefinesPartialInterface(const core::tFrameworkElement& parent, const rrlib::rtti::tType& interface_type)
{
  tInterfaceModifier* modifier = GetModifier(parent);
  if (modifier)
  {
    return modifier->Implementation().PartialInterface(interface_type);
  }
  return tInterfaceBase::tPrimaryPortType::ANY;
}

core::tAbstractPortCreationInfo MakeCreationInfo(const rrlib::rtti::tType& interface_type, const std::string& name, core::tFrameworkElement& parent_interface, bool partial_interface, bool shared)
{
  core::tAbstractPortCreationInfo result;
  result.data_type = interface_type;
  if (partial_interface)
  {
    auto partial_type = static_cast<const internal::tInterfaceTypeInfo&>(interface_type.SharedTypeInfo()).GetPartialType();
    result.data_type = partial_type ? partial_type : result.data_type;
  }
  result.parent = &parent_interface;
  result.flags |= tFlag::INTERFACE;
  GetAggregator(parent_interface, &result.flags);
  result.name = name;
  assert(result.flags.Get(tFlag::EMITS_DATA) || result.flags.Get(tFlag::ACCEPTS_DATA));
  if (shared)
  {
    result.flags |= tFlag::SHARED_PORT;
  }
  return result;
}

void FindInterfacesBelowImplementation(std::vector<tInterfaceBase>& result, core::tFrameworkElement& parent, const rrlib::rtti::tType& type, bool skip_derived_interfaces)
{
  for (auto it = parent.ChildrenBegin(); it != parent.ChildrenEnd(); ++it)
  {
    bool is_backend = typeid(*it) == typeid(tInterfaceBase::tBackend);
    if (is_backend)
    {
      tInterfaceBase::tBackend& candidate = static_cast<tInterfaceBase::tBackend&>(*it);
      if (candidate.IsPrimaryBackend() && (candidate.GetDataType() == type || ((!skip_derived_interfaces) && rrlib::rtti::conversion::tStaticCastOperation::IsImplicitlyConvertibleTo(candidate.GetDataType(), type))))
      {
        result.emplace_back(&candidate);
        continue;
      }
    }
    if ((!it->IsPort()) || is_backend)
    {
      FindInterfacesBelowImplementation(result, *it, type, skip_derived_interfaces);
    }
  }
}

//! Connector with operations for custom connecting attached
class tConversionConnector : public core::tConnector
{

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

  tConversionConnector(core::tAbstractPort& source_port, core::tAbstractPort& destination_port, const core::tConnectOptions& connect_options) :
    tConnector(source_port, destination_port, connect_options, this->connect_options.conversion_operations),
    connect_options(connect_options),
    original_flags(connect_options.flags)
  {}

  const core::tConnectOptions& ConnectOptions() const
  {
    connect_options.flags = original_flags;
    return connect_options;
  }

  const core::tConnectOptions& ConnectOptions(const core::tConnectionFlag direction_flag) const
  {
    connect_options.flags.Set(core::tConnectionFlag::DIRECTION_TO_SOURCE, direction_flag == core::tConnectionFlag::DIRECTION_TO_SOURCE);
    connect_options.flags.Set(core::tConnectionFlag::DIRECTION_TO_DESTINATION, direction_flag == core::tConnectionFlag::DIRECTION_TO_DESTINATION);
    return connect_options;
  }

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

  /*!
   * Applied connect operations
   * Notably, the flags are only accessed within this file (with runtime structure lock).
   * Therefore, they can be temporarily modified (avoiding all the overhead for copying options)
   */
  mutable core::tConnectOptions connect_options;
  const core::tConnectionFlags original_flags;

};

bool CompiledConnectOptions(const rrlib::rtti::conversion::tConversionOperationSequence& options)
{
  bool raw = (options.Size() >= 1 && ((!options[0].second) || (options[0].second->Parameter() && options.GetParameterValue(0).GetType() != options[0].second->Parameter().GetType()))) ||
             (options.Size() >= 2 && ((!options[1].second) || (options[1].second->Parameter() && options.GetParameterValue(1).GetType() != options[1].second->Parameter().GetType())));
  return !raw;
}

}

void tInterfaceBase::operator()(core::tAbstractPortCreationInfo& creation_info) const
{
  if ((!Backend()) || (Backend() && Backend()->convenience_port_type))
  {
    creation_info.flags |= tFlag::READY; // tComponent::cNO_PORT_NAME_BUILDER;
  }
  if (!Backend())
  {
    creation_info.flags |= tFlag::DELETED;
    return;
  }

  creation_info.parent = &Backend()->primary_backend;

  auto aggregator = GetAggregator(*creation_info.parent);
  if (aggregator && aggregator->GetFlag(tFlag::INTERFACE))
  {
    creation_info.flags |= static_cast<const core::tPortGroup&>(*aggregator).GetDefaultPortFlags();
  }
  const int cRELEVANT_FLAGS = (tFlag::SHARED | tFlag::SENSOR_DATA_PORT | tFlag::CONTROLLER_DATA_PORT).Raw();
  creation_info.flags |= core::tFrameworkElementFlags(creation_info.parent->GetAllFlags().Raw() & cRELEVANT_FLAGS);

  if (Backend()->primary_backend.IsPartialInterface() && Backend()->primary_backend.PrimaryPortType() != tPrimaryPortType::ANY && Backend()->primary_backend.relation_backend_mapping.front().second == nullptr)
  {
    creation_info.flags |= tFlag::DELETED;
  }
  else if (creation_info.parent)
  {
    auto modifier = GetModifier(*creation_info.parent);
    if (modifier)
    {
      modifier->Implementation().AdjustPortCreationInfo(creation_info);
    }
  }

  return;
}

core::tConnector* tInterfaceBase::ConnectTo(const tInterfaceBase& partner, const core::tConnectOptions& connect_options)
{
  if (Backend() && partner.Backend())
  {
    for (auto this_backend : Backend()->relation_backend_mapping)
    {
      for (auto other_backend : partner.Backend()->primary_backend.relation_backend_mapping)
      {
        if (this_backend.second && other_backend.second && this_backend.first - Backend()->primary_relation_id == other_backend.first - partner.Backend()->primary_relation_id)
        {
          return this_backend.second->ConnectTo(*other_backend.second, connect_options);
        }
      }
    }
  }
  return nullptr;
}

tInterfaceBase::tBackend* tInterfaceBase::CreateBackend(rrlib::rtti::tType interface_type, tInterfaceBase* parent, const std::string& name, tPrimaryPortType primary_port_type, const tConnectFunction& custom_connect_function, int primary_relation_id, bool convience_port_type)
{
  assert(parent);
  if (parent->Backend() == nullptr)
  {
    return nullptr;
  }
  tBackend* parent_backend = parent->Backend()->GetBackend(primary_relation_id);
  bool partial_interface = false;
  assert(parent_backend || parent->Backend()->IsPartialInterface());
  if (!parent_backend)
  {
    const internal::tInterfaceTypeInfo& info = static_cast<const internal::tInterfaceTypeInfo&>(interface_type.SharedTypeInfo());
    interface_type = info.GetPartialType();
    partial_interface = interface_type && primary_port_type != tPrimaryPortType::ANY;
    if (partial_interface)
    {
      parent_backend = parent->Backend();
    }
  }
  return parent_backend ? new tInterfaceBase::tBackend(interface_type, convience_port_type ? parent->ParentComponent() : parent->Backend(), parent_backend, primary_relation_id, name, convience_port_type, custom_connect_function, nullptr, parent->Backend()->PrimaryPortType(), partial_interface) : nullptr;
}

tInterfaceBase::tBackend* tInterfaceBase::CreateBackend(rrlib::rtti::tType interface_type, tInterfaceBase::tBackend* parent, const std::string& name, tPrimaryPortType primary_port_type, const tConnectFunction& custom_connect_function, int primary_relation_id, bool convience_port_type)
{
  const internal::tInterfaceTypeInfo& info = static_cast<const internal::tInterfaceTypeInfo&>(interface_type.SharedTypeInfo());
  return parent ? new tInterfaceBase::tBackend(info.GetPartialType(), convience_port_type ? parent->parent_component : parent, parent, primary_relation_id, name, convience_port_type, custom_connect_function, nullptr, parent->PrimaryPortType(), true) : nullptr;
}

void tInterfaceBase::SetConfigEntry(const rrlib::uri::tPath& config_entry)
{
  uint interface_count = 0;
  auto primary_backend = this->Backend();
  if (primary_backend)
  {
    for (auto backend : primary_backend->primary_backend.all_backends)
    {
      auto aggregator = GetAggregator(*backend);
      if (aggregator && (!aggregator->IsPort()) && aggregator->GetFlag(tFlag::INTERFACE) && aggregator->GetFlag(tFlag::PARAMETER_INTERFACE))
      {
        auto parameter_info = backend->GetAnnotation<parameters::internal::tParameterInfo>();
        if (!parameter_info)
        {
          parameter_info = &backend->EmplaceAnnotation<parameters::internal::tParameterInfo>();
        }
        std::stringstream temp;  // Temporary solution until tParameterInfo class accepts paths
        temp << config_entry;
        parameter_info->SetConfigEntry(temp.str(), false);
        interface_count++;
      }
    }
    if (!interface_count)
    {
      FINROC_LOG_PRINT(WARNING, "No parameters backend in interface ", *primary_backend);
    }
  }
  else
  {
    FINROC_LOG_PRINT(WARNING, "Called on empty interface wrapper");
  }
}


tInterfaceBase::tBackend::tBackend(const rrlib::rtti::tType& interface_type, core::tFrameworkElement* parent_component, core::tFrameworkElement* parent, int primary_relation_id, const std::string& name, bool convenience_port_type, const tConnectFunction& custom_connect_function, tCreateMissingComponentInterfaceFunction create_missing_component_interface_function, tPrimaryPortType primary_port_type, bool partial_interface) :
  tAbstractPort(MakeCreationInfo(interface_type, name, *parent, partial_interface || tScopedExtraConstructorParameters::Get()->partial_interface || ModifierDefinesPartialInterface(*parent, interface_type), tScopedExtraConstructorParameters::Get()->shared)),
  parent_component(parent_component),
  primary_backend(*this),
  custom_connect_function(custom_connect_function),
  convenience_port_type(convenience_port_type),
  primary_relation_id(primary_relation_id),
  create_missing_component_interface_function(create_missing_component_interface_function),
  primary_port_type(primary_port_type),
  partial_interface(static_cast<const internal::tInterfaceTypeInfo&>(GetDataType().SharedTypeInfo()).GetFullType() != GetDataType()),
  partial_interface_primary_port_type(true)
{
  all_backends.emplace_back(this);
  tBackend* primary_relation_backend = this;
  if (this->partial_interface && primary_port_type != tPrimaryPortType::ANY)
  {
    auto aggregator = GetAggregator(*this);
    auto partial_definition = ModifierDefinesPartialInterface(*aggregator, interface_type);
    if (partial_definition != tPrimaryPortType::ANY)
    {
      this->partial_interface_primary_port_type = partial_definition == primary_port_type;
    }
    else
    {
      bool sensor_parent = (aggregator && (aggregator->GetFlag(tFlag::SENSOR_DATA) || partial_definition == tInterfaceBase::tPrimaryPortType::SENSOR_PORT));
      bool controller_parent = (aggregator && (aggregator->GetFlag(tFlag::CONTROLLER_DATA) || partial_definition == tInterfaceBase::tPrimaryPortType::CONTROLLER_PORT));
      if ((sensor_parent && primary_port_type == tPrimaryPortType::CONTROLLER_PORT) || (controller_parent && primary_port_type == tPrimaryPortType::SENSOR_PORT))
      {
        this->partial_interface_primary_port_type = false;
      }
    }
    if (!this->partial_interface_primary_port_type)
    {
      primary_relation_backend = nullptr;
    }
  }
  relation_backend_mapping.emplace_back(primary_relation_id, primary_relation_backend);
}

tInterfaceBase::tBackend::tBackend(core::tAbstractPortCreationInfo& creation_info, tBackend& primary) :
  tAbstractPort(creation_info),
  parent_component(primary.parent_component),
  primary_backend(primary),
  custom_connect_function(primary.custom_connect_function),
  convenience_port_type(false),
  primary_relation_id(primary.primary_relation_id),
  create_missing_component_interface_function(nullptr),
  primary_port_type(primary.primary_port_type),
  partial_interface(primary.partial_interface),
  partial_interface_primary_port_type(primary.partial_interface_primary_port_type)
{
}

void tInterfaceBase::tBackend::ConnectChildPortsByName(tBackend& destination, const core::tConnectOptions& connect_options)
{
  if (!CompiledConnectOptions(connect_options.conversion_operations))
  {
    throw std::runtime_error("This function requires compiled connect options");
  }

  struct tPerSelectOperation
  {
    const internal::tPortSelectConversionOperation* operation = nullptr;
    const utils::tPortSelector* selector = nullptr;
  } select_operations[2];
  size_t select_operation_count = 0;
  bool nested_connect_options_differ = false;

  struct tNestedOperation
  {
    const rrlib::rtti::conversion::tRegisteredConversionOperation* operation = nullptr;
    size_t index = 0;
  };
  struct tNestedOperations
  {
    tNestedOperation operations[2];
    size_t count = 0;

    void Add(const tNestedOperation& op)
    {
      operations[count] = op;
      count++;
    }

  } nested_operations_non_convertible, nested_operations_convertible;

  for (size_t i = 0; i < connect_options.conversion_operations.Size(); i++)
  {
    tNestedOperation nested_operation;
    nested_operation.operation = connect_options.conversion_operations[i].second;
    nested_operation.index = i;
    bool nested_operation_valid = true;
    if (typeid(*connect_options.conversion_operations[i].second) == typeid(internal::tPortSelectConversionOperation))
    {
      tPerSelectOperation data;
      data.operation = static_cast<const internal::tPortSelectConversionOperation*>(connect_options.conversion_operations[i].second);
      data.selector = connect_options.conversion_operations.GetParameterValue(i).Get<utils::tPortSelector>();
      select_operations[select_operation_count] = data;
      select_operation_count++;

      nested_connect_options_differ = data.operation->NestedVariant() != data.operation;
      nested_operation_valid = data.operation->NestedVariant();
    }
    if (nested_operation_valid)
    {
      nested_operations_non_convertible.Add(nested_operation);
      if (connect_options.conversion_operations[i].second != &cCONNECT_BY_NAME_OPERATION)
      {
        nested_operations_convertible.Add(nested_operation);
      }
    }
  }

  for (auto port = this->ChildPortsBegin(); port != this->ChildPortsEnd(); ++port)
  {
    auto other_port_element = destination.GetChild(port->GetName());
    if (other_port_element && other_port_element->IsPort())
    {
      auto& other_port = static_cast<core::tAbstractPort&>(*other_port_element);

      // Check whether to include port
      bool skip = false;
      for (size_t i = 0; i < select_operation_count; i++)
      {
        const tPerSelectOperation& data = select_operations[i];
        if (!data.operation->NestedOnly())
        {
          if (data.operation->ExcludeOperation())
          {
            skip |= data.selector->Accepts(*port) || data.selector->Accepts(other_port);
          }
          else
          {
            skip |= (!data.selector->Accepts(*port)) && (!data.selector->Accepts(other_port));
          }
        }
      }
      if (skip)
      {
        continue;
      }


      if (port->GetDataType().GetTypeClassification() == rrlib::rtti::tTypeClassification::RPC_TYPE)
      {
        auto option_flags = connect_options.flags;
        option_flags.Set(core::tConnectionFlag::DIRECTION_TO_SOURCE, false);
        option_flags.Set(core::tConnectionFlag::DIRECTION_TO_DESTINATION, false);
        port->ConnectTo(other_port, option_flags);
      }
      else
      {
        if (IsInterfaceType(port->GetDataType()))
        {
          bool convertible = port->GetDataType() == other_port.GetDataType() || IsDerivedFrom(port->GetDataType(), other_port.GetDataType()) || IsDerivedFrom(other_port.GetDataType(), port->GetDataType());
          const tNestedOperations& operations = convertible ? nested_operations_convertible : nested_operations_non_convertible;
          if ((!nested_connect_options_differ) && operations.count == connect_options.conversion_operations.Size())
          {
            port->ConnectTo(other_port, connect_options);
          }
          else
          {
            core::tConnectOptions nested_options(connect_options.flags);
            if (operations.count)
            {
              nested_options.conversion_operations = operations.count == 1 ? rrlib::rtti::conversion::tConversionOperationSequence(*operations.operations[0].operation) : rrlib::rtti::conversion::tConversionOperationSequence(*operations.operations[0].operation, *operations.operations[1].operation);
            }
            for (size_t i = 0; i < operations.count; i++)
            {
              if (nested_options.conversion_operations[i].second->Parameter() && connect_options.conversion_operations.GetParameterValue(operations.operations[i].index))
              {
                nested_options.conversion_operations.SetParameterValue(i, connect_options.conversion_operations.GetParameterValue(operations.operations[i].index));
              }
            }
            port->ConnectTo(other_port, nested_options);
          }
        }
        else
        {
          port->ConnectTo(other_port, connect_options.flags);
        }
      }
    }
  }
}

core::tConnector* tInterfaceBase::tBackend::CreateConnector(core::tAbstractPort& destination, const core::tConnectOptions& connect_options)
{
  if (!(CompiledConnectOptions(connect_options.conversion_operations)))
  {
    assert(connect_options.conversion_operations.Size() >= 1);
    const rrlib::rtti::conversion::tRegisteredConversionOperation* operations[2] = { nullptr, nullptr };

    // Resolve ambiguous operations
    for (size_t i = 0; i < connect_options.conversion_operations.Size(); i++)
    {
      auto operation = connect_options.conversion_operations[i];
      if (operation.second)
      {
        operations[i] = operation.second;
      }
      else
      {
        auto& registered_operations = rrlib::rtti::conversion::tRegisteredConversionOperation::GetRegisteredOperations();
        for (auto it = registered_operations.operations.Begin(); it != registered_operations.operations.End(); ++it)
        {
          if (strcmp((*it)->Name(), operation.first) == 0)
          {
            operations[i] = *it;
            break;
          }
        }
      }

      if (!operations[i])
      {
        throw std::runtime_error(std::string("Operation lookup failed: ") + operation.first);
      }
    }

    rrlib::rtti::conversion::tConversionOperationSequence conversion = connect_options.conversion_operations.Size() == 1 ? rrlib::rtti::conversion::tConversionOperationSequence(*operations[0]) : rrlib::rtti::conversion::tConversionOperationSequence(*operations[0], *operations[1], connect_options.conversion_operations.IntermediateType() ? connect_options.conversion_operations.IntermediateType() : destination.GetDataType());

    // ############
    // Convert any parameters provided as strings to their required types (see tConversionOperationSequence.cpp)
    // ############
    for (size_t i = 0; i < 2; i++)
    {
      const rrlib::rtti::conversion::tRegisteredConversionOperation* operation = operations[i];
      if (operation && operation->Parameter() && connect_options.conversion_operations.GetParameterValue(i))
      {
        const rrlib::rtti::tTypedConstPointer& value = connect_options.conversion_operations.GetParameterValue(i);
        if (value.GetType() == operation->Parameter().GetType())
        {
          conversion.SetParameterValue(i, value);
        }
        else if (value.GetType() == rrlib::rtti::tDataType<std::string>())
        {
          rrlib::serialization::tStringInputStream stream(*value.Get<std::string>());
          auto buffer = operation->Parameter().GetType().CreateGenericObject();
          buffer->Deserialize(stream);
          conversion.SetParameterValue(i, *buffer);
        }
        else
        {
          throw std::runtime_error(std::string("Parameter ") + operation->Parameter().GetName() + " has invalid type");
        }
      }
    }

    return new tConversionConnector(*this, destination, core::tConnectOptions(conversion, connect_options.flags));
  }
  return new tConversionConnector(*this, destination, connect_options);
}

bool tInterfaceBase::tBackend::CreateOutputPort(int primary_relation_id)
{
  auto backend = GetBackend(primary_relation_id);
  if (!backend)
  {
    return false;
  }
  auto component_interface = GetAggregator(*backend);
  if ((!component_interface) || (!internal::IsComponent(component_interface->GetParent())))
  {
    return false;
  }
  if (component_interface->GetFlag(tFlag::INTERFACE_FOR_RPC_PORTS))
  {
    int last_relation = primary_relation_id & 0xFF;
    bool derived_from_backend_is_output = CreateOutputPort(primary_relation_id >> 8);
    if (last_relation == internal::tPortTypeRelation::ePTR_CLIENT_IF_INPUT)
    {
      return !derived_from_backend_is_output;
    }
    else if (last_relation == internal::tPortTypeRelation::ePTR_SERVER_IF_INPUT)
    {
      return derived_from_backend_is_output;
    }
  }
  if (component_interface->GetFlag(tFlag::INTERFACE_FOR_OUTPUTS))
  {
    return true;
  }
  if (component_interface->GetFlag(tFlag::INTERFACE_FOR_INPUTS) || component_interface->GetFlag(tFlag::PARAMETER_INTERFACE))
  {
    return false;
  }
  throw std::runtime_error("Unspecified port direction");
}

core::tAbstractPort* tInterfaceBase::tBackend::CreatePort(const core::tAbstractPortCreationInfo& creation_info, int primary_relation_id) const
{
  auto modifier = GetModifier(*creation_info.parent);
  return (modifier ? modifier->Implementation() : cMODIFIER_DEFAULT_IMPLEMENTATION).CreatePort(creation_info, primary_relation_id);
}

std::vector<tInterfaceBase> tInterfaceBase::FindInterfacesBelow(core::tFrameworkElement& parent, const rrlib::rtti::tType& type, bool skip_derived_interfaces)
{
  std::vector<tInterfaceBase> result;
  if (type.GetTypeClassification() == rrlib::rtti::tTypeClassification::PORT_COMPOSITE_INTERFACE)
  {
    FindInterfacesBelowImplementation(result, parent, type, skip_derived_interfaces);
  }
  return result;
}

tInterfaceBase::tBackend* tInterfaceBase::tBackend::GetBackend(int primary_relation_id)
{
  if (&primary_backend != this)
  {
    return primary_backend.GetBackend(primary_relation_id);
  }

  for (auto & entry : relation_backend_mapping)
  {
    if (entry.first == primary_relation_id)
    {
      return entry.second;
    }
  }

  core::tFrameworkElement* parent = nullptr;
  bool do_not_create_primary_port_type = relation_backend_mapping.front().second == nullptr;
  bool partial_interface_direction_is_output = GetAggregator(*this)->GetFlag(tFlag::INTERFACE_FOR_OUTPUTS);
  bool partial_interface_primary_relation_direction_is_output = !partial_interface_direction_is_output;
  bool backend_for_client_port = false;
  if (GetParent() && typeid(*GetParent()).name() == typeid(tBackend).name())
  {
    parent = static_cast<tBackend&>(*GetParent()).GetBackend(primary_relation_id);
  }
  else if (core::tFrameworkElementTags::IsTagged(*this->GetParent(), cINTERFACE_TAG_SINGLE_BACKEND_INSTANTIATION))
  {
    parent = this->GetParent();
  }
  else if (this->partial_interface && (!IsPartOfPartialInstantiation(primary_relation_id, this->partial_interface_primary_port_type)))
  {
    parent = nullptr; // Skip
  }
  else
  {
    // Actually process relation
    std::vector<int> relation_list;
    tFrameworkElement* component_interface = this->GetParent();
    int relation_id = primary_relation_id;
    if ((!component_interface) || (!internal::IsComponent(component_interface->GetParent())))
    {
      FINROC_LOG_PRINT(WARNING, "Generic creation of port composite interfaces with multiple port types only works on components");
      throw std::runtime_error("Generic creation of port composite interfaces with multiple port types only works on components");
    }

    const core::tFrameworkElementFlags relevant_flags = tFlag::SENSOR_DATA | tFlag::CONTROLLER_DATA | tFlag::INTERFACE_FOR_INPUTS | tFlag::INTERFACE_FOR_OUTPUTS | tFlag::PROXY_INTERFACE | tFlag::PARAMETER_INTERFACE;
    tInterfaceModifier* interface_modifier = GetModifier(*component_interface);

    // Compute opcode sequence
    {
      while (relation_id)
      {
        int opcode = relation_id & 0xFF;
        relation_list.push_back(opcode);
        relation_id = relation_id >> 8;
      }
      std::reverse(relation_list.begin(), relation_list.end());
    }

    tFrameworkElement* parent_candidate = do_not_create_primary_port_type ? nullptr : component_interface;
    core::tFrameworkElementFlags use_these_original_flags;
    if (do_not_create_primary_port_type)
    {
      assert(partial_interface && primary_port_type != tPrimaryPortType::ANY);
      use_these_original_flags = tFlag::INTERFACE_FOR_DATA_PORTS | (primary_port_type == tPrimaryPortType::SENSOR_PORT ? tFlag::SENSOR_DATA : tFlag::CONTROLLER_DATA) | (partial_interface_primary_relation_direction_is_output ? tFlag::INTERFACE_FOR_OUTPUTS : tFlag::INTERFACE_FOR_INPUTS);
      use_these_original_flags.Set(tFlag::PROXY_INTERFACE, component_interface->GetFlag(tFlag::PROXY_INTERFACE));
    }

    int remaining_relations = relation_list.size();
    for (int opcode : relation_list)
    {
      remaining_relations--;
      core::tFrameworkElementFlags original_flags = use_these_original_flags.Raw() ? use_these_original_flags : parent_candidate->GetAllFlags();
      use_these_original_flags = core::tFrameworkElementFlags();
      core::tFrameworkElementFlags target_set_flags = core::tFrameworkElementFlags(original_flags.Raw() & relevant_flags.Raw());
      core::tFrameworkElementFlags target_unset_flags = core::tFrameworkElementFlags((~original_flags.Raw()) & relevant_flags.Raw());

      typedef internal::tPortTypeRelation tOpCode;
      switch (opcode)
      {
      case tOpCode::ePTR_COUNTER_PART:
      case tOpCode::ePTR_COUNTER_PART_PARAMETER_IF_INPUT:
        if (original_flags.Get(tFlag::CONTROLLER_DATA) && (!original_flags.Get(tFlag::SENSOR_DATA)))
        {
          target_set_flags.Set(tFlag::SENSOR_DATA);
          target_set_flags.Set(tFlag::CONTROLLER_DATA, false);
          target_unset_flags.Set(tFlag::CONTROLLER_DATA);
          target_unset_flags.Set(tFlag::SENSOR_DATA, false);
        }
        if (original_flags.Get(tFlag::SENSOR_DATA) && (!original_flags.Get(tFlag::CONTROLLER_DATA)))
        {
          target_set_flags.Set(tFlag::CONTROLLER_DATA);
          target_set_flags.Set(tFlag::SENSOR_DATA, false);
          target_unset_flags.Set(tFlag::SENSOR_DATA);
          target_unset_flags.Set(tFlag::CONTROLLER_DATA, false);
        }
        if (original_flags.Get(tFlag::INTERFACE_FOR_INPUTS) && (!original_flags.Get(tFlag::INTERFACE_FOR_OUTPUTS)))
        {
          target_set_flags.Set(tFlag::INTERFACE_FOR_OUTPUTS);
          target_set_flags.Set(tFlag::INTERFACE_FOR_INPUTS, false);
          target_set_flags.Set(tFlag::PARAMETER_INTERFACE, false);
          target_unset_flags.Set(tFlag::INTERFACE_FOR_INPUTS);
          target_unset_flags.Set(tFlag::INTERFACE_FOR_OUTPUTS, false);
        }
        if (original_flags.Get(tFlag::INTERFACE_FOR_OUTPUTS) && (!original_flags.Get(tFlag::INTERFACE_FOR_INPUTS)))
        {
          if (opcode == tOpCode::ePTR_COUNTER_PART_PARAMETER_IF_INPUT)
          {
            target_set_flags = tFlag::PARAMETER_INTERFACE;
            target_unset_flags = core::tFrameworkElementFlags();
          }
          else
          {
            target_set_flags.Set(tFlag::INTERFACE_FOR_INPUTS);
            target_set_flags.Set(tFlag::INTERFACE_FOR_OUTPUTS, false);
            target_unset_flags.Set(tFlag::INTERFACE_FOR_OUTPUTS);
            target_unset_flags.Set(tFlag::INTERFACE_FOR_INPUTS, false);
          }
        }
        break;
      case internal::tPortTypeRelation::ePTR_INPUT:
        target_set_flags.Set(tFlag::INTERFACE_FOR_INPUTS);
        target_set_flags.Set(tFlag::INTERFACE_FOR_OUTPUTS, false);
        target_unset_flags.Set(tFlag::INTERFACE_FOR_OUTPUTS);
        target_unset_flags.Set(tFlag::INTERFACE_FOR_INPUTS, false);
        break;
      case internal::tPortTypeRelation::ePTR_OUTPUT:
        target_set_flags.Set(tFlag::INTERFACE_FOR_OUTPUTS);
        target_set_flags.Set(tFlag::INTERFACE_FOR_INPUTS, false);
        target_set_flags.Set(tFlag::PARAMETER_INTERFACE, false);
        target_unset_flags.Set(tFlag::INTERFACE_FOR_INPUTS);
        target_unset_flags.Set(tFlag::INTERFACE_FOR_OUTPUTS, false);
        break;
      case internal::tPortTypeRelation::ePTR_PARAMETER:
        target_set_flags = tFlag::PARAMETER_INTERFACE;
        target_unset_flags = core::tFrameworkElementFlags();
        break;
      case internal::tPortTypeRelation::ePTR_SERVER_IF_INPUT:
      case internal::tPortTypeRelation::ePTR_CLIENT_IF_INPUT:
        backend_for_client_port = (remaining_relations == 0) && ((opcode == internal::tPortTypeRelation::ePTR_CLIENT_IF_INPUT && original_flags.Get(tFlag::INTERFACE_FOR_INPUTS)) || (opcode == internal::tPortTypeRelation::ePTR_SERVER_IF_INPUT && original_flags.Get(tFlag::INTERFACE_FOR_OUTPUTS)));
        target_set_flags = tFlag::INTERFACE_FOR_RPC_PORTS;
        target_unset_flags = (partial_interface && (!parent_candidate)) ? target_set_flags : core::tFrameworkElementFlags(); // With partially instantiated interfaces, create service ports if the port types they are derived from are also created
        break;
      default:
        break;
      }

      core::tFrameworkElement* new_candidate = nullptr;
      size_t candidate_name_length_difference = std::numeric_limits<size_t>::max();
      auto component = component_interface->GetParent();
      for (auto it = component->ChildrenBegin(); it != component->ChildrenEnd(); ++it)
      {
        if ((!it->IsPort()) && it->GetFlag(tFlag::INTERFACE) && (it->GetAllFlags().Raw() & target_set_flags.Raw()) == target_set_flags.Raw() && (it->GetAllFlags().Raw() & target_unset_flags.Raw()) == 0)
        {
          size_t name_length_difference = std::abs(static_cast<long>(component_interface->GetName().length()) - static_cast<long>(it->GetName().length()));
          if (name_length_difference < candidate_name_length_difference)
          {
            new_candidate = &*it;
            candidate_name_length_difference = name_length_difference;
          }
        }
      }

      if ((!new_candidate) && this->IsPartialInterface() && remaining_relations)
      {
        use_these_original_flags = target_set_flags;
        parent_candidate = nullptr;
        continue;
      }

      // Not-yet-created component interfaces - until there is a generic way to do this
      if ((!new_candidate) && create_missing_component_interface_function)
      {
        new_candidate = (*create_missing_component_interface_function)(component_interface->GetParent(), target_set_flags);
      }

      if ((!new_candidate) && interface_modifier)
      {
        use_these_original_flags = target_set_flags;
        parent_candidate = nullptr;
        continue;
      }

      if (new_candidate)
      {
        component_interface = new_candidate;
        parent_candidate = new_candidate;
      }
      else
      {
        std::stringstream message;
        message << "Generic creation of port composite interface failed: No interface with relation " << make_builder::GetEnumString(static_cast<tOpCode>(opcode)) << " found below " << *component_interface->GetParent();
        FINROC_LOG_PRINT(WARNING, message.str());
        throw std::runtime_error(message.str());
      }
    }
    assert(remaining_relations == 0);

    parent = parent_candidate;
    if (interface_modifier)
    {
      parent = interface_modifier->Implementation().GetComponentInterface(parent_candidate && parent_candidate->GetFlag(tFlag::INTERFACE) ? static_cast<core::tPortGroup*>(parent_candidate) : nullptr, primary_relation_id);
    }
  }

  if (!parent)
  {
    relation_backend_mapping.emplace_back(primary_relation_id, nullptr);
    return nullptr;
  }

  for (auto backend : all_backends)
  {
    if (backend->GetParent() == parent)
    {
      relation_backend_mapping.emplace_back(primary_relation_id, backend);
      return backend;
    }
  }

  // Create new backend below this parent
  assert(parent != this->GetParent());
  core::tAbstractPortCreationInfo secondary_creation_info;
  secondary_creation_info.data_type = this->GetDataType();
  secondary_creation_info.name = GetName();
  secondary_creation_info.parent = parent;
  secondary_creation_info.flags = core::tFrameworkElementFlags(tFlag::INTERFACE);
  auto aggregator = GetAggregator(*parent, &secondary_creation_info.flags);
  if (backend_for_client_port && aggregator->GetFlag(tFlag::INTERFACE_FOR_RPC_PORTS))
  {
    secondary_creation_info.flags.Set(tFlag::OUTPUT_PORT, backend_for_client_port);
  }
  if (this->GetFlag(tFlag::SHARED))
  {
    secondary_creation_info.flags |= tFlag::SHARED;
  }
  all_backends.push_back(new tBackend(secondary_creation_info, *this));
  relation_backend_mapping.emplace_back(primary_relation_id, all_backends.back());
  return all_backends.back();
}

core::tFrameworkElementFlags tInterfaceBase::tBackend::GetDefaultPortFlags(bool generic_port_backend) const
{
  core::tFrameworkElementFlags result;
  if (generic_port_backend)
  {
    GetAggregator(*this, &result);
  }
  else
  {
    auto aggregator = GetAggregator(*this);
    if (aggregator && aggregator->GetFlag(tFlag::INTERFACE))
    {
      if (aggregator->GetFlag(tFlag::PROXY_INTERFACE))
      {
        result |= (tFlag::ACCEPTS_DATA | tFlag::EMITS_DATA | tFlag::PUSH_STRATEGY);
      }
      result |= static_cast<const core::tPortGroup&>(*aggregator).GetDefaultPortFlags();
    }
  }
  const int cRELEVANT_FLAGS = (tFlag::SHARED | tFlag::SENSOR_DATA_PORT | tFlag::CONTROLLER_DATA_PORT).Raw();
  result |= core::tFrameworkElementFlags(this->GetAllFlags().Raw() & cRELEVANT_FLAGS);
  return result;
}

bool tInterfaceBase::tBackend::IsPartOfPartialInstantiation(int primary_relation_id, bool partial_instantiation_variant_primary_port_type)
{
  typedef internal::tPortTypeRelation tOpCode;
  int switch_count = 0;
  while (primary_relation_id)
  {
    int opcode = primary_relation_id & 0xFF;
    switch_count += ((opcode == tOpCode::ePTR_COUNTER_PART || opcode == tOpCode::ePTR_COUNTER_PART_PARAMETER_IF_INPUT) ? 1 : 0);
    primary_relation_id = primary_relation_id >> 8;
  }
  bool primary_port_type_relation_id = (switch_count % 2) == 0;
  return primary_port_type_relation_id == partial_instantiation_variant_primary_port_type;
}

void tInterfaceBase::tBackend::OnConnect(tAbstractPort& partner, bool partner_is_destination)
{
  if (primary_backend.operation_on_all_elements_pending)
  {
    return;
  }

  tBackend& other = static_cast<tBackend&>(partner);
  bool connect_all_backends = this->IsPrimaryBackend() && other.IsPrimaryBackend();

  // Are any conversion operations set?
  const tConversionConnector* conversion_connector = nullptr;
  {
    if (partner_is_destination)
    {
      for (auto it = this->OutgoingConnectionsBegin(); it != this->OutgoingConnectionsEnd(); ++it)
      {
        if (&it->Destination() == &partner && typeid(*it) == typeid(tConversionConnector))
        {
          conversion_connector = &static_cast<const tConversionConnector&>(*it);
          break;
        }
      }
    }
    else
    {
      for (auto it = this->IncomingConnectionsBegin(); it != this->IncomingConnectionsEnd(); ++it)
      {
        if (&it->Source() == &partner && typeid(*it) == typeid(tConversionConnector))
        {
          conversion_connector = &static_cast<const tConversionConnector&>(*it);
          break;
        }
      }
    }
  }

  primary_backend.operation_on_all_elements_pending = true;
  try
  {
    if (!conversion_connector)
    {
      throw std::runtime_error("Invalid connector type");
    }

    if (primary_backend.custom_connect_function)
    {
      if (partner_is_destination)
      {
        primary_backend.custom_connect_function(*this, other, conversion_connector->ConnectOptions());
      }
      else
      {
        primary_backend.custom_connect_function(other, *this, conversion_connector->ConnectOptions());
      }
      primary_backend.operation_on_all_elements_pending = false;
      return;
    }

    // Connect all matching backends and ports
    for (auto this_backend : primary_backend.relation_backend_mapping)
    {
      for (auto other_backend : other.primary_backend.primary_backend.relation_backend_mapping)
      {
        if (this_backend.second && other_backend.second && this_backend.first - primary_backend.primary_relation_id == other_backend.first - other.primary_backend.primary_relation_id && (connect_all_backends || this_backend.second == this || other_backend.second == &other))
        {
          core::tConnectionFlag direction = (this->IsOutputPort() == this_backend.second->IsOutputPort() ? partner_is_destination : (!partner_is_destination)) ? core::tConnectionFlag::DIRECTION_TO_DESTINATION : core::tConnectionFlag::DIRECTION_TO_SOURCE;
          this_backend.second->ConnectTo(*other_backend.second, conversion_connector->ConnectOptions(direction));
          this_backend.second->ConnectChildPortsByName(*other_backend.second, conversion_connector->ConnectOptions(direction));
        }
      }
    }
  }
  catch (const std::exception& e)
  {
    FINROC_LOG_PRINT(WARNING, "Connecting failed: ", e);
  }
  primary_backend.operation_on_all_elements_pending = false;
}

void tInterfaceBase::tBackend::OnDisconnect(tAbstractPort& partner, bool partner_is_destination)
{
  bool& pending = primary_backend.primary_backend.operation_on_all_elements_pending;
  tBackend& other = static_cast<tBackend&>(partner).primary_backend;
  if (pending || other.operation_on_all_elements_pending || partner_is_destination)
  {
    return;
  }

  pending = true;
  try
  {
    // Update other backend connection info
    for (auto this_backend : this->primary_backend.all_backends)
    {
      for (auto other_backend : other.primary_backend.all_backends)
      {
        this_backend->DisconnectFrom(*other_backend);
      }
    }

    // Disconnect all ports to partner backends (this should also cover cases with custom connect function)
    for (auto backend : primary_backend.all_backends)
    {
      for (auto port = backend->ChildPortsBegin(); port != backend->ChildPortsEnd(); ++port)
      {
        for (auto partner = port->IncomingConnectionsBegin(); partner != port->IncomingConnectionsEnd(); ++partner)
        {
          if (std::count(other.all_backends.begin(), other.all_backends.end(), partner->Source().GetParent()))
          {
            port->DisconnectFrom(partner->Source());
          }
        }
        for (auto partner = port->OutgoingConnectionsBegin(); partner != port->OutgoingConnectionsEnd(); ++partner)
        {
          if (std::count(other.all_backends.begin(), other.all_backends.end(), partner->Destination().GetParent()))
          {
            port->DisconnectFrom(partner->Destination());
          }
        }
      }
    }
  }
  catch (const std::exception& e)
  {
    FINROC_LOG_PRINT(WARNING, "Disconnecting failed: ", e);
  }
  pending = false;
}

void tInterfaceBase::tBackend::OnInitialization()
{
  bool& pending = primary_backend.operation_on_all_elements_pending;
  if (!pending)
  {
    pending = true;
    for (auto backend : primary_backend.all_backends)
    {
      if (backend != this)
      {
        backend->Init();
      }
    }
    pending = false;
  }
}

void tInterfaceBase::tBackend::OnManagedDelete()
{
  rrlib::thread::tLock lock1(GetStructureMutex());

  if (!core::tRuntimeEnvironment::ShuttingDown())
  {
    bool& pending = primary_backend.operation_on_all_elements_pending;
    if (!pending)
    {
      pending = true;
      for (auto backend : primary_backend.all_backends)
      {
        if (backend != this)
        {
          backend->ManagedDelete();
        }
      }
      pending = false;
    }
  }

  tAbstractPort::OnManagedDelete();
}

tInterfaceBase::tScopedExtraConstructorParameters tInterfaceBase::tScopedExtraConstructorParameters::Get()
{
  static tExtraConstructorParameters parameters;
  return tScopedExtraConstructorParameters(core::tRuntimeEnvironment::GetInstance().GetStructureMutex(), &parameters);  //
}

void tInterfaceBase::tSecondaryPortModifier::operator()(core::tAbstractPortCreationInfo& creation_info) const
{
  creation_info.name = name;
  creation_info.parent = &backend;
  creation_info.flags |= backend.GetDefaultPortFlags(false);

  {
    auto modifier = GetModifier(backend);
    if (modifier)
    {
      modifier->Implementation().AdjustPortCreationInfo(creation_info);
    }
  }
}

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