source: finroc_plugins_composite_ports/internal/tInterfaceTypeInfo.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/tInterfaceTypeInfo.h
 *
 * \author  Max Reichardt
 *
 * \date    2020-02-07
 *
 * \brief   Contains tInterfaceTypeInfo
 *
 * \b tInterfaceTypeInfo
 *
 * Internal type info for port composite interface types
 *
 */
//----------------------------------------------------------------------
#ifndef __plugins__structure__internal__tInterfaceTypeInfo_h__
#define __plugins__structure__internal__tInterfaceTypeInfo_h__

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

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

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

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

class tInterfaceFactory;

/*!
 * \param Framework element to check
 * \return Whether framework element is a component
 */
bool IsComponent(const core::tFrameworkElement* element);

//----------------------------------------------------------------------
// Class declaration
//----------------------------------------------------------------------
//! Port composite interface type info
/*!
 * Internal type info for port composite interface types
 */
class tInterfaceTypeInfo : public rrlib::rtti::detail::tTypeInfo::tSharedInfo
{

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

  typedef tInterfaceBase(*tCreateFunction)(const std::string& name, core::tPortGroup* parent);

  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);

  tInterfaceTypeInfo(const rrlib::rtti::detail::tTypeInfo* type_info, tCreateFunction create_function, rrlib::util::tManagedConstCharPointer name) :
    tSharedInfo(type_info, std::move(name), nullptr, 0),
    create_function(create_function)
  {}

  ~tInterfaceTypeInfo();

  /*!
   * \return Create function for this interface type (generic instance)
   */
  tCreateFunction CreateFunction() const
  {
    return create_function;
  }

  /*!
   * \return Returns type info for (non-generic) interface of type TInterface
   */
  template <typename TInterface>
  static rrlib::rtti::tType FindType()
  {
    auto name = GenerateName(typeid(TInterface).name());
    rrlib::rtti::tType type = rrlib::rtti::tType::FindType(name.Get());
    return type.GetTypeClassification() == rrlib::rtti::tTypeClassification::PORT_COMPOSITE_INTERFACE ? type : rrlib::rtti::tType();
  }

  /*!
   * \return Full type of interface
   */
  rrlib::rtti::tType GetFullType() const
  {
    return rrlib::rtti::tType(type_info_full);
  }

  /*!
   * \return Partial type in case this interface type has one
   */
  rrlib::rtti::tType GetPartialType() const
  {
    return type_info_partial ? rrlib::rtti::tType(type_info_partial) : rrlib::rtti::tType();
  }

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

  /*! Create function for this interface type (generic instance) */
  tCreateFunction create_function;

  /*! Pointer to partial type info in case this interface type has a partial type info (created and deleted by this class) */
  rrlib::rtti::detail::tTypeInfo* type_info_partial = nullptr;

  /*! Pointer to full type info (possibly relevant if this interface type has a partial type info) */
  const rrlib::rtti::detail::tTypeInfo* type_info_full = nullptr;

  /*! Generates interface type name from rtti name */
  static rrlib::util::tManagedConstCharPointer GenerateName(const char* rtti_name);
};

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


#endif