plugin.hpp

Go to the documentation of this file.

/*
 * Copyright 2020 Robert Bosch GmbH
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 * SPDX-License-Identifier: Apache-2.0
 */
#pragma once
 
#include <type_traits>  // for is_base_of, conditional<>, false_type
 
/*
 * When creating a plugin, only the symbols that are loaded should be made
 * visible. This can be achieved by setting compile options:
 *
 *     -fvisibility=hidden -fvisibility-inlines-hidden
 *
 * This macro then makes select symbols that we want to export visible again.
 */
#define DLL_PUBLIC __attribute__((visibility("default")))
 
/*
 * This definition is used for tracking changes to the plugin manifest.
 */
#define CLOE_PLUGIN_MANIFEST_VERSION 1
 
/*
 * This can be set to a compatible setting as defined in the system header
 * dlfcn.h. The default is equivalent to RTLD_LOCAL. Prefer defining this
 * with the defines from the system header rather than on the command line.
 *
 * Note that if set to anything other than 0, one of RTLD_NOW and RTLD_LAZY
 * must be specified in addition, as per the manual of dlopen().
 *
 * Example: RTLD_NOLOAD | RTLD_GLOBAL | RTLD_LAZY
 */
#ifndef CLOE_PLUGIN_GLIBC_DLOPEN_MODE
#define CLOE_PLUGIN_GLIBC_DLOPEN_MODE 0
#endif
 
/*
 * This complex looking beast of code basically contains two switches on the
 * base type of the factory xFactoryType. Ideally, we'd like to be able to
 * just be able to do this:
 *
 *     xFactoryType::PLUGIN_TYPE,
 *
 * But PLUGIN_TYPE and PLUGIN_API_VERSION are static members of the base
 * factories, and are thus not available on the xFactoryType. So first we
 * find out through is_base_of and conditional.
 */
#define BASE_CLOE_FACTORY(xFactoryType)                                                    \
  std::conditional<std::is_base_of<::cloe::ControllerFactory, xFactoryType>::value,        \
                   ::cloe::ControllerFactory,                                              \
                   typename std::conditional<                                              \
                       std::is_base_of<::cloe::SimulatorFactory, xFactoryType>::value,     \
                       ::cloe::SimulatorFactory,                                           \
                       typename std::conditional<                                          \
                           std::is_base_of<::cloe::ComponentFactory, xFactoryType>::value, \
                           ::cloe::ComponentFactory, std::false_type>::type>::type>::type
 
#define EXPORT_CLOE_PLUGIN(xFactoryType)                                                           \
  extern "C" DLL_PUBLIC const uint8_t cloe_plugin_manifest_version = CLOE_PLUGIN_MANIFEST_VERSION; \
  extern "C" DLL_PUBLIC const ::cloe::PluginManifest cloe_plugin_manifest{                         \
      BASE_CLOE_FACTORY(xFactoryType)::PLUGIN_TYPE,                                                \
      BASE_CLOE_FACTORY(xFactoryType)::PLUGIN_API_VERSION,                                         \
      "cloe_plugin_create",                                                                        \
      CLOE_PLUGIN_GLIBC_DLOPEN_MODE,                                                               \
  };                                                                                               \
  extern "C" DLL_PUBLIC ::cloe::ModelFactory* cloe_plugin_create() { return new xFactoryType{}; }
 
namespace cloe {
 
// Forward declarations:
class ControllerFactory;
class SimulatorFactory;
class ComponentFactory;
class ModelFactory;
 
struct PluginManifest {
  const char* plugin_type;
 
  const char* plugin_type_version;
 
  const char* factory_symbol;
 
  int glibc_dlopen_mode;
};
 
}  // namespace cloe