text: // Copyright (C) 2018-2019 Intel Corporation
  // SPDX-License-Identifier: Apache-2.0
  //
  
  #include <vpu/frontend/frontend.hpp>
  
  #include <string>
  #include <vector>
  #include <list>
  #include <memory>
  
  namespace vpu {
  
  namespace {
  
  class NoneStage final : public StageNode {
  public:
      using StageNode::StageNode;
  
  private:
      StagePtr cloneImpl() const override {
          return std::make_shared<NoneStage>(*this);
      }
  
      void propagateScaleFactorsImpl(
              const SmallVector<float>&,
              ScalePropagationStep,
              StageDataInfo<float>& scaleInfo) override {
          for (const auto& outEdge : outputEdges()) {
              scaleInfo.setOutput(outEdge, 1.0f);
          }
      }
  
      void propagateDataOrderImpl(StageDataInfo<DimsOrder>& orderInfo) override {
      }
  
      void getDataStridesRequirementsImpl(StageDataInfo<StridesRequirement>& stridesInfo) override {
      }
  
      void finalizeDataLayoutImpl() override {
      }
  
      void getBatchSupportInfoImpl(StageDataInfo<BatchSupport>& batchInfo) override {
      }
  
      StageSHAVEsRequirements getSHAVEsRequirementsImpl() const override {
          return StageSHAVEsRequirements::NotNeeded;
      }
  
      void serializeParamsImpl(BlobSerializer&) const override {
      }
  
      void serializeDataImpl(BlobSerializer&) const override {
      }
  };
  
  }  // namespace
  
  Stage StageBuilder::addNoneStage(
          const Model::Ptr& model,
          const std::string& name,
          const ie::CNNLayerPtr& layer,
          const DataVector& inputs,
          const DataVector& outputs) {
      return model->addNewStage<NoneStage>(
          name,
          StageType::None,
          layer,
          {inputs},
          {outputs});
  }
  
  }  // namespace vpu
  