service-maker/includes/object.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 NVIDIA_DEEPSTREAM_OBJECT
#define NVIDIA_DEEPSTREAM_OBJECT
 
#include <string>
#include "yaml-cpp/yaml.h"
 
// opaque structures
typedef struct _GValue GValue;
typedef struct _GstObject GstObject;
 
namespace deepstream {
 
class SignalHandler;
class SignalEmitter;
 
class Object {
public:
 
  class Value {
   public:
    Value();
    Value(char value);
    Value(unsigned char value);
    Value(int value);
    Value(unsigned int value);
    Value(long value);
    Value(unsigned long value);
    Value(float value);
    Value(double value);
    Value(const std::string value);
    Value(const char* value);
    Value(bool value);
 
    Value(const Value& other);
 
    virtual ~Value();
 
    Value &operator=(const Value& other);
 
    operator char() const;
    operator unsigned char() const;
    operator int() const;
    operator unsigned int() const;
    operator long() const;
    operator unsigned long() const;
    operator float() const;
    operator double() const;
    operator std::string() const;
    operator const char*() const;
    operator bool() const;
 
    bool isChar() const;
    bool isUnsignedChar() const;
    bool isInteger() const;
    bool isUnsignedInteger() const;
    bool isFloat() const;
    bool isString() const;
    bool isBoolean() const;
 
   private:
    GValue* value_;
 
    Value(unsigned long, int);
 
   friend class Object;
  };
 
  Object();
  Object(unsigned long type_id, const std::string& name);
 
  Object(const Object&);
 
  Object(Object&&) noexcept;
 
  Object& operator=(const Object&);
 
  Object& operator=(Object&&) noexcept;
 
  virtual ~Object();
 
  const std::string getName() const;
 
  explicit operator bool () const noexcept { return object_ != nullptr; }
 
  bool operator == (const Object& other) noexcept { return object_ == other.object_; }
 
  GstObject* give();
 
  GstObject* getGObject() {
    return object_;
  }
 
  Object& take(GstObject* object);
 
  Object& seize(GstObject* object);
 
  Object& set(const YAML::Node& params);
 
  // set the properties through ke/value pair directly
  Object& set(const std::string& name, const Value& value) {
    this->set_(name, value);
    return *this;
  }
 
  // template for setting multiple properties
  template<typename T, typename... Args>
  Object& set(const std::string& name, const T& value, const Args&... args) {
    set_(name, Value(value));
    if constexpr (sizeof...(args) > 0) {
      this->set(args...);
    }
    return *this;
  }
 
  template<typename T, typename... Args>
  Object& getProperty(const std::string& name, T& value, Args&... args) {
    value = (T) get_(name);
    if constexpr (sizeof...(args) > 0) {
      this->getProperty(args...);
    }
    return *this;
  }
 
  std::vector<std::string> listSignals(bool is_action);
 
  bool connectSignal(const std::string&signal_name, SignalHandler& handler);
 
  void emitSignal(const std::string&signal_name, va_list args);
 
  static unsigned long type();
 
protected:
  GstObject* object_;
 
  virtual void set_(const std::string& name, const Value& value);
  virtual void set_(const std::string& name, const YAML::Node& value);
  virtual Value get_(const std::string&name);
 
friend class Pipeline;
friend class Element;
};
 
}
 
#endif