genapi.hpp

#pragma once
 
#include "../_cexports/c_gen_api.h"
 
#include "../global.hpp"
 
namespace Cvb
{
 
  CVB_BEGIN_INLINE_NS


  namespace GenApi
  {
 
    class NodeMap;
    using NodeMapPtr = std::shared_ptr<NodeMap>;
 
    class BooleanNode;
    using BooleanNodePtr = std::shared_ptr<BooleanNode>;
 
    class CategoryNode;
    using CategoryNodePtr = std::shared_ptr<CategoryNode>;
 
    class CommandNode;
    using CommandNodePtr = std::shared_ptr<CommandNode>;
 
    class EnumEntryNode;
    using EnumEntryNodePtr = std::shared_ptr<EnumEntryNode>;
 
    class EnumerationNode;
    using EnumerationNodePtr = std::shared_ptr<EnumerationNode>;
 
    class FloatNode;
    using FloatNodePtr = std::shared_ptr<FloatNode>;
 
    class FloatRegNode;
    using FloatRegNodePtr = std::shared_ptr<FloatRegNode>;
 
    class IntRegNode;
    using IntRegNodePtr = std::shared_ptr<IntRegNode>;
 
    class IntegerNode;
    using IntegerNodePtr = std::shared_ptr<IntegerNode>;
 
    class SelectorNode;
    using SelectorNodePtr = std::shared_ptr<SelectorNode>;
 
    class Node;
    using NodePtr = std::shared_ptr<Node>;
 
    class PortNode;
    using PortNodePtr = std::shared_ptr<PortNode>;
 
    class RegisterNode;
    using RegisterNodePtr = std::shared_ptr<RegisterNode>;
 
    class StringNode;
    using StringNodePtr = std::shared_ptr<StringNode>;
 
    class StringRegNode;
    using StringRegNodePtr = std::shared_ptr<StringRegNode>;
 
    class ValueNode;
    using ValueNodePtr = std::shared_ptr<ValueNode>;
 
    class NodeMapEnumerator;
    using NodeMapEnumeratorPtr = std::shared_ptr<NodeMapEnumerator>;
 
    class FWUpdater;
 
    enum class NodeMapInfo
    {
      Vendor                = CExports::NMI_Vendor,
      Model                 = CExports::NMI_Model,
      SchemaVersionMajor    = CExports::NMI_SchemaVersionMajor,
      SchemaVersionMinor    = CExports::NMI_SchemaVersionMinor,
      SchemaVersionSubMinor = CExports::NMI_SchemaVersionSubMinor,
      DeviceVersionMajor    = CExports::NMI_DeviceVersionMajor,
      DeviceVersionMinor    = CExports::NMI_DeviceVersionMinor,
      DeviceVersionSubMinor = CExports::NMI_DeviceVersionSubMinor,
      Namespace             = CExports::NMI_Namespace,
      ProductGUID           = CExports::NMI_ProductGUID,
      VersionGUID           = CExports::NMI_VersionGUID,
      Tooltip               = CExports::NMI_Tooltip
    };
 
    enum class NodeInfo
    {
 
      Name            = CExports::NI_Name,
      DisplayName     = CExports::NI_DisplayName,
      AccessMode      = CExports::NI_AccessMode,
      Max             = CExports::NI_Max,
      Min             = CExports::NI_Min,
      Increment       = CExports::NI_Increment,
      NumEnumEntries  = CExports::NI_NumEnumEntries,
      Streamable      = CExports::NI_Streamable,
      CachingMode     = CExports::NI_CachingMode,
      ToolTip         = CExports::NI_Tooltip,
      Description     = CExports::NI_Description,
      Visibility      = CExports::NI_Visibility,
      PollingTime     = CExports::NI_PollingTime,
      EventID         = CExports::NI_EventID,
      RegisterAddress = CExports::NI_RegisterAddress,
      RegisterLength  = CExports::NI_RegisterLength,
      Representation  = CExports::NI_Representation,
      Unit            = CExports::NI_Unit,
      AliasName       = CExports::NI_AliasName,
      Deprecated      = CExports::NI_Deprecated,
      Feature         = CExports::NI_Feature
    };

    enum class NumberRepresentation
    {
      Undefined = CExports::NR_Undefined,
      Linear = CExports::NR_Linear,
      Logarithmic = CExports::NR_Logarithmic,
      Boolean = CExports::NR_Boolean,
      PureNumber = CExports::NR_PureNumber,
      HexNumber = CExports::NR_HexNumber,
      IPv4 = CExports::NR_IPv4,
      MAC = CExports::NR_MAC
    };
    enum class NumberRepresentation {…};
 
    enum class NodeList
    {
      ChildNode = CExports::NL_ChildNode,
      Selected  = CExports::NL_Selected,
      EnumEntry = CExports::NL_EnumEntry,
      Selecting = CExports::NL_Selecting
    };

    enum class ReadWriteVerify
    {
      No = CExports::VM_NO,
      WriteOnly = CExports::VM_WO,
      ReadOnly = CExports::VM_RO,
      Both = CExports::VM_RW
    };
    enum class ReadWriteVerify {…};


    enum class AccessMode
    {
      NotImplemented = CExports::AM_NI,
      NotAvailable = CExports::AM_NA,
      NotApplicable [[deprecated("use AccessMode::NotAvailable instead")]] = NotAvailable,
      ReadOnly = CExports::AM_RO,
      WriteOnly = CExports::AM_WO,
      ReadWrite = CExports::AM_RW
    };
    enum class AccessMode {…};

    enum class CacheMode
    {
      NoCache = CExports::CM_NoCache,
      WriteThrough = CExports::CM_WriteThrough,
      WriteAround = CExports::CM_WriteAround
    };
    enum class CacheMode {…};


    enum class Visibility
    {
      Invisible = CExports::NV_Invisible,
      Beginner = CExports::NV_Beginner,
      Expert = CExports::NV_Expert,
      Guru = CExports::NV_Guru
    };
    enum class Visibility {…};


    enum class FirmwareUpdateInfo
    {
      Key = CExports::FWUI_Key,
      Value = CExports::FWUI_Value,
      LanguageCode = CExports::FWUI_LanguageCode
    };
    enum class FirmwareUpdateInfo {…};
 
  }  // namespace GenApi
 
  using GenApi::NodeMapPtr;
 
  using GenApi::BooleanNodePtr;
  using GenApi::CategoryNodePtr;
  using GenApi::CommandNodePtr;
  using GenApi::EnumEntryNodePtr;
  using GenApi::EnumerationNodePtr;
  using GenApi::FloatNodePtr;
  using GenApi::FloatRegNodePtr;
  using GenApi::IntegerNodePtr;
  using GenApi::IntRegNodePtr;
  using GenApi::NodePtr;
  using GenApi::PortNodePtr;
  using GenApi::RegisterNodePtr;
  using GenApi::SelectorNodePtr;
  using GenApi::StringNodePtr;
  using GenApi::StringRegNodePtr;
  using GenApi::ValueNodePtr;

  using GenApi::AccessMode;
  using GenApi::CacheMode;

  using GenApi::NodeInfo;
  using GenApi::NodeList;

  using GenApi::NumberRepresentation;
  using GenApi::ReadWriteVerify;
  using GenApi::Visibility;

  using GenApi::FWUpdater;
  using GenApi::NodeMapEnumerator;
 
  CVB_END_INLINE_NS
 
}  // namespace Cvb