source: finroc_plugins_composite_ports/internal/tInterfaceTypeInfo.cpp @ 25:677b14542f29

//
// 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/tInterfaceTypeInfo.cpp
 *
 * \author  Max Reichardt
 *
 * \date    2020-02-07
 *
 */
//----------------------------------------------------------------------
#include "plugins/composite_ports/internal/tInterfaceTypeInfo.h"

//----------------------------------------------------------------------
// External includes (system with <>, local with "")
//----------------------------------------------------------------------
#include "core/port/tPortFactory.h"
#include "core/tFrameworkElementTags.h"

//----------------------------------------------------------------------
// Internal includes with ""
//----------------------------------------------------------------------
#include "plugins/composite_ports/interface_types.h"

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

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

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

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

//----------------------------------------------------------------------
// Const values
//----------------------------------------------------------------------

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

namespace
{

core::tEdgeAggregator* GetAggregator(core::tFrameworkElement& element)
{
  return static_cast<core::tEdgeAggregator*>(element.GetFlag(core::tFrameworkElementFlag::EDGE_AGGREGATOR) ? &element : element.GetParentWithFlags(core::tFrameworkElementFlag::EDGE_AGGREGATOR));
}

}

class tInterfaceFactory : public core::tPortFactory
{
  virtual core::tAbstractPort& CreatePortImplementation(const std::string& port_name, core::tFrameworkElement& parent, const rrlib::rtti::tType& type, core::tFrameworkElement::tFlags flags) override
  {
    core::tEdgeAggregator* parent_interface = GetAggregator(parent);
    if ((!parent_interface) || (!IsComponent(parent_interface->GetParent())) || (!parent_interface->GetFlag(core::tFrameworkElementFlag::INTERFACE)))
    {
      throw std::runtime_error("Port composite interfaces can only be created for components");
    }

    auto& interface_type_info = static_cast<const tInterfaceTypeInfo&>(type.SharedTypeInfo());
    tInterfaceTypeInfo::tCreateFunction create_function = interface_type_info.CreateFunction();
    if (!create_function)
    {
      throw std::runtime_error("No create action registered for interface type (typically done in rtti.cpp)");
    }

    tInterfaceBase::tScopedExtraConstructorParameters extra_contructor_parameters;
    if (interface_type_info.GetFullType() != type)
    {
      extra_contructor_parameters = tInterfaceBase::tScopedExtraConstructorParameters::Get();
      extra_contructor_parameters->partial_interface = true;
    }

    tInterfaceBase result = (*create_function)(port_name, static_cast<core::tPortGroup*>(parent_interface));
    if (flags.Get(core::tFrameworkElementFlag::FINSTRUCTED))
    {
      result.Backend()->SetFlag(core::tFrameworkElementFlag::FINSTRUCTED);
    }
    return *result.GetWrapped();
  }

  virtual bool HandlesDataType(const rrlib::rtti::tType& type) override
  {
    return IsInterfaceType(type);
  }
};

tInterfaceFactory default_port_composite_interface_factory;

bool IsComponent(const core::tFrameworkElement* element)
{
  return element && (core::tFrameworkElementTags::IsTagged(*element, "module") || core::tFrameworkElementTags::IsTagged(*element, "group"));
}

tInterfaceTypeInfo::tInterfaceTypeInfo(const rrlib::rtti::detail::tTypeInfo* type_info, tCreateFunction create_function, int auto_registered, bool create_partial_type, const std::type_info& partial_type_info) :
  tSharedInfo(type_info, GenerateName(type_info->std_type_info.name()), nullptr, 0),
  create_function(create_function)
{
  this->type_info_full = type_info;
  if (create_partial_type)
  {
    this->type_info_partial = new rrlib::rtti::detail::tTypeInfo(partial_type_info, type_info->type_traits | (rrlib::rtti::trait_flags::cHAS_UNDERLYING_TYPE | rrlib::rtti::trait_flags::cIS_CAST_TO_UNDERLYING_TYPE_IMPLICIT | rrlib::rtti::trait_flags::cIS_REINTERPRET_CAST_FROM_UNDERLYING_TYPE_VALID | rrlib::rtti::trait_flags::cIS_CAST_FROM_UNDERLYING_TYPE_IMPLICIT), type_info, type_info->element_type, nullptr, type_info->size);
    auto partial_shared_info = new tInterfaceTypeInfo(this->type_info_partial, create_function, rrlib::util::tManagedConstCharPointer((rrlib::rtti::tType(type_info).GetName() + " (partial)").c_str(), true));
    this->type_info_partial->shared_info = partial_shared_info;
    partial_shared_info->type_info_full = type_info;
    partial_shared_info->type_info_partial = this->type_info_partial;
    assert(GetPartialType().GetHandle() == GetFullType().GetHandle() + 1);
  }
}

tInterfaceTypeInfo::~tInterfaceTypeInfo()
{
  if (this->type_info_partial && this->type_info_full->shared_info == this)
  {
    tInterfaceTypeInfo* shared_info_partial = static_cast<tInterfaceTypeInfo*>(this->type_info_partial->shared_info);
    delete shared_info_partial;
    delete this->type_info_partial;
  }
}

rrlib::util::tManagedConstCharPointer tInterfaceTypeInfo::GenerateName(const char* rtti_name)
{
  auto from_rrlib_rtti = rrlib::rtti::detail::tTypeInfo::GetDefaultTypeNameFromRttiName(rtti_name);
  std::string rrlib_rtti_string(from_rrlib_rtti.Get());
  auto index = rrlib_rtti_string.find("<");
  if (index == std::string::npos)
  {
    return from_rrlib_rtti;
  }
  rrlib_rtti_string = rrlib_rtti_string.substr(0, index);
  return rrlib::util::tManagedConstCharPointer(rrlib_rtti_string.c_str(), true);
}

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