service-maker/includes/element.hpp

Go to the documentation of this file.

/*
 * SPDX-FileCopyrightText: Copyright (c) 2024-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
 * SPDX-License-Identifier: Apache-2.0
 *
 * 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.
 */
 
#ifndef ELEMENT_HPP
#define ELEMENT_HPP
 
#include <string>
#include <memory>
#include <vector>
#include <typeinfo>
#include <algorithm>
 
#include "yaml-cpp/yaml.h"
#include "object.hpp"
#include "buffer_probe.hpp"
#include "signal_emitter.hpp"
#include "signal_handler.hpp"
 
namespace deepstream {
 
class Pipeline;
 
class Element : public Object {
 public:
 
   typedef enum {
    INVALID,
    EMPTY,
    READY,
    PAUSED,
    PLAYING
  } State;
 
  Element(const std::string& type_name, std::string name = std::string());
 
  Element(const Object&);
 
  Element(Object&&);
 
  virtual ~Element();
 
  Element & link(Element &dst, std::pair<std::string, std::string> hint);
 
  Element& link(Element &other);
 
  BufferProbe* getProbe(const std::string& name) {
    return find_<BufferProbe>(name);
  }
 
  Element& addProbe(const std::string& plugin_name,
                    const std::string& probe_name,
                    const std::string probe_tip = "");
 
  template<typename... Args>
  Element& addProbe(const std::string& plugin_name,
                    const std::string& probe_name,
                    const std::string probe_tip = "",
                    const Args&... args) {
    addProbe(plugin_name, probe_name, probe_tip);
    auto probe = getProbe(probe_name);
    if (probe && (sizeof...(args) > 0)) {
      probe->set(args...);
    }
    return *this;
  }
 
  Element& addProbe(BufferProbe* probe, const std::string probe_tip  = "");
 
  SignalHandler* getSignalHandler(const std::string& name) {
    return find_<SignalHandler>(name);
  }
 
  Element& connectSignal(const std::string&signal_name, SignalHandler* handler);
 
  Element& connectSignal(const std::string& plugin_name,
                         const std::string& handler_name,
                         const std::string& signal_names);
 
  template<typename... Args>
  Element& connectSignal(const std::string& plugin_name,
                         const std::string& handler_name,
                         const std::string& signal_names,
                         const Args&... args) {
    connectSignal(plugin_name, handler_name, signal_names);
    auto handler = getSignalHandler(handler_name);
    if (handler && (sizeof...(args) > 0)) {
      handler->set(args...);
    }
    return *this;
  }
 
  const Pipeline& getPipeline() {
    return *pipeline_;
  }
 
  bool setState (Element::State state);
 
protected:
  Element(GstObject* object);
 
  Element& add_(CustomObject* object);
 
  // buffer probes, signal handlers, signal emitters are held by its target
  // element as shared pointers.
  std::shared_ptr<std::unordered_map<std::string, std::unique_ptr<CustomObject>>> objects_;
  // pointer to the pipeline
  Pipeline* pipeline_=nullptr;
 
  template<class T>
  T* find_(const std::string& name) {
    auto itr = find_if(
      objects_->begin(),
      objects_->end(),
      [&](const auto& pair) {
        return pair.first == name && dynamic_cast<T*>(pair.second.get());
      }
    );
    if (itr != objects_->end()) return dynamic_cast<T*>(itr->second.get());
    return nullptr;
  }
 
friend class Pipeline;
};
 
} // namespace deepstream
 
#endif