inference-engine/include/cpp/ie_plugin_cpp.hpp

   1 // Copyright (C) 2018-2019 Intel Corporation
   2 // SPDX-License-Identifier: Apache-2.0
   3 //
   4
   5 /**
   6  * @brief This is a header file for the Inference Engine plugin C++ API
   7  * @file ie_plugin_cpp.hpp
   8  */
   9 #pragma once
  10
  11 #include <map>
  12 #include <string>
  13 #include <memory>
  14
  15 #include "ie_plugin.hpp"
  16 #include "details/ie_exception_conversion.hpp"
  17 #include "cpp/ie_executable_network.hpp"
  18 #include "ie_plugin_ptr.hpp"
  19 #include "ie_cnn_network.h"
  20
  21
  22 namespace InferenceEngine {
  23
  24 /**
  25  * @brief This class is a C++ API wrapper for IInferencePlugin.
  26  * It can throw exceptions safely for the application, where it is properly handled.
  27  */
  28 class InferencePlugin {
  29     InferenceEnginePluginPtr actual;
  30
  31 public:
  32     /** @brief A default constructor */
  33     InferencePlugin() = default;
  34
  35     /**
  36      * @brief Constructs a plugin instance from the given pointer.
  37      * @param pointer Initialized Plugin pointer
  38      */
  39     explicit InferencePlugin(const InferenceEnginePluginPtr &pointer) : actual(pointer) {}
  40
  41     /**
  42      * @brief Wraps original method
  43      * IInferencePlugin::GetVersion
  44      */
  45     const Version *GetVersion() {
  46         const Version *versionInfo = nullptr;
  47         actual->GetVersion(versionInfo);
  48         if (versionInfo == nullptr) {
  49             THROW_IE_EXCEPTION << "Unknown device is used";
  50         }
  51         return versionInfo;
  52     }
  53
  54     /**
  55      * @deprecated Use InferencePlugin::LoadNetwork(ICNNNetwork &, const std::map<std::string, std::string> &)
  56      * @brief Wraps original method IInferencePlugin::LoadNetwork(ICNNNetwork &, ResponseDesc *)
  57      * @param network A network object to load
  58      */
  59     INFERENCE_ENGINE_DEPRECATED
  60     void LoadNetwork(ICNNNetwork &network) {
  61         IE_SUPPRESS_DEPRECATED_START
  62         CALL_STATUS_FNC(LoadNetwork, network);
  63         IE_SUPPRESS_DEPRECATED_END
  64     }
  65
  66     /**
  67      * @brief Wraps original method
  68      * IInferencePlugin::LoadNetwork(IExecutableNetwork::Ptr&, ICNNNetwork&, const std::map<std::string, std::string> &, ResponseDesc*).
  69      * @param network A network object to load
  70      * @param config A map of configuration options
  71      * @return Created Executable Network object
  72      */
  73     ExecutableNetwork LoadNetwork(ICNNNetwork &network, const std::map<std::string, std::string> &config) {
  74         IExecutableNetwork::Ptr ret;
  75         CALL_STATUS_FNC(LoadNetwork, ret, network, config);
  76         return ExecutableNetwork(ret, actual);
  77     }
  78
  79     /**
  80      * @brief Wraps original method
  81      * IInferencePlugin::LoadNetwork(IExecutableNetwork::Ptr&, ICNNNetwork&, const std::map<std::string, std::string> &, ResponseDesc*).
  82      * @param network A network object to load
  83      * @param config A map of configuration options
  84      * @return Created Executable Network object
  85      */
  86     ExecutableNetwork LoadNetwork(CNNNetwork network, const std::map<std::string, std::string> &config) {
  87         IExecutableNetwork::Ptr ret;
  88         CALL_STATUS_FNC(LoadNetwork, ret, network, config);
  89         if (ret.get() == nullptr) THROW_IE_EXCEPTION << "Internal error: pointer to executable network is null";
  90         return ExecutableNetwork(ret, actual);
  91     }
  92
  93     /**
  94      * @deprecated Use IExecutableNetwork to create IInferRequest.
  95      * @brief Wraps original method IInferencePlugin::Infer(const BlobMap&, BlobMap&, ResponseDesc *)
  96      * @param input A map of input blobs accessed by input names
  97      * @param result A map of output blobs accessed by output names
  98      */
  99     INFERENCE_ENGINE_DEPRECATED
 100     void Infer(const BlobMap &input, BlobMap &result) {
 101         IE_SUPPRESS_DEPRECATED_START
 102         CALL_STATUS_FNC(Infer, input, result);
 103         IE_SUPPRESS_DEPRECATED_END
 104     }
 105
 106     /**
 107      * @deprecated Use IInferRequest to get performance counters
 108      * @brief Wraps original method IInferencePlugin::GetPerformanceCounts
 109      * @return Map of layers names to profiling information for that layers
 110      */
 111     INFERENCE_ENGINE_DEPRECATED
 112     std::map<std::string, InferenceEngineProfileInfo> GetPerformanceCounts() const {
 113         std::map<std::string, InferenceEngineProfileInfo> perfMap;
 114         IE_SUPPRESS_DEPRECATED_START
 115         CALL_STATUS_FNC(GetPerformanceCounts, perfMap);
 116         IE_SUPPRESS_DEPRECATED_END
 117         return perfMap;
 118     }
 119
 120     /**
 121      * @brief Wraps original method
 122      * IInferencePlugin::AddExtension
 123      * @param extension Pointer to loaded Extension
 124      */
 125     void AddExtension(InferenceEngine::IExtensionPtr extension) {
 126         CALL_STATUS_FNC(AddExtension, extension);
 127     }
 128
 129     /**
 130      * @brief Wraps original method
 131      * IInferencePlugin::SetConfig
 132      * @param config A configuration map
 133      */
 134     void SetConfig(const std::map<std::string, std::string> &config) {
 135         CALL_STATUS_FNC(SetConfig, config);
 136     }
 137
 138     /**
 139      * @brief Wraps original method
 140      * IInferencePlugin::ImportNetwork
 141      * @param modelFileName A path to the imported network
 142      * @param config A configuration map
 143      * @return Created Executable Network object
 144      */
 145     ExecutableNetwork ImportNetwork(const std::string &modelFileName, const std::map<std::string, std::string> &config) {
 146         IExecutableNetwork::Ptr ret;
 147         CALL_STATUS_FNC(ImportNetwork, ret, modelFileName, config);
 148         return ExecutableNetwork(ret, actual);
 149     }
 150
 151     /**
 152      * @deprecated Use InferencePlugin::QueryNetwork(const ICNNNetwork &, const std::map<std::string, std::string> &, QueryNetworkResult &) const
 153      * @brief Wraps original method
 154      * IInferencePlugin::QueryNetwork(const ICNNNetwork&, QueryNetworkResult& ) const
 155      * @param network A network object to query
 156      * @param res Query results
 157      */
 158     INFERENCE_ENGINE_DEPRECATED
 159     void QueryNetwork(const ICNNNetwork &network, QueryNetworkResult &res) const {
 160         QueryNetwork(network, { }, res);
 161     }
 162
 163     /**
 164      * @brief Wraps original method
 165      * IInferencePlugin::QueryNetwork(const ICNNNetwork&, const std::map<std::string, std::string> &, QueryNetworkResult&) const
 166      * @param network A network object to query
 167      * @param config A configuration map
 168      * @param res Query results
 169      */
 170     void QueryNetwork(const ICNNNetwork &network, const std::map<std::string, std::string> &config, QueryNetworkResult &res) const {
 171         actual->QueryNetwork(network, config, res);
 172         if (res.rc != OK) THROW_IE_EXCEPTION << res.resp.msg;
 173     }
 174
 175     /**
 176      * @brief Converts InferenceEngine to InferenceEnginePluginPtr pointer
 177      * @return Wrapped object
 178      */
 179     operator InferenceEngine::InferenceEnginePluginPtr() {
 180         return actual;
 181     }
 182
 183     /**
 184      * @deprecated Deprecated since HeteroPluginPtr is deprecated
 185      * @brief Converts InferenceEngine to HeteroPluginPtr pointer
 186      * @return Wrapped Hetero object if underlined object is HeteroPlugin instance, nullptr otherwise
 187      */
 188     IE_SUPPRESS_DEPRECATED_START
 189     operator InferenceEngine::HeteroPluginPtr() {
 190         return actual;
 191     }
 192     IE_SUPPRESS_DEPRECATED_END
 193
 194     /**
 195      * @brief Shared pointer on InferencePlugin object
 196      */
 197     using Ptr = std::shared_ptr<InferencePlugin>;
 198 };
 199 }  // namespace InferenceEngine