gevserver.hpp

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


  namespace GevServer
  {
    struct LogicalNetworkInterface;
 
 
 
    class ServerBase;
    using ServerBasePtr = std::shared_ptr<ServerBase>;
 
    class Server;
    using ServerPtr = std::shared_ptr<Server>;
 
    
    class ServerGev3;
    using ServerGev3Ptr = std::shared_ptr<ServerGev3>;
 
    class Node;
    using NodePtr = std::shared_ptr<Node>;
 
    class NodeMap;
    using NodeMapPtr = std::shared_ptr<NodeMap>;
 
    class StreamBase;
    using StreamBasePtr = std::shared_ptr<StreamBase>;
        
    class Stream;
    using StreamPtr = std::shared_ptr<Stream>;
 
    class StreamGev3;
    using StreamGev3Ptr = std::shared_ptr<StreamGev3>;
 
 
    class ValueNode;
    using ValueNodePtr = std::shared_ptr<ValueNode>;
 
    class StringNode;
    using StringNodePtr = std::shared_ptr<StringNode>;
 
    class StringRegNode;
    using StringRegNodePtr = std::shared_ptr<StringRegNode>;
 
    class BooleanNode;
    using BooleanNodePtr = std::shared_ptr<BooleanNode>;
 
    class CategoryNode;
    using CategoryNodePtr = std::shared_ptr<CategoryNode>;
 
    class IntegerBaseNode;
    using IntegerBaseNodePtr = std::shared_ptr<IntegerBaseNode>;
 
    class FloatBaseNode;
    using FloatBaseNodePtr = std::shared_ptr<FloatBaseNode>;
 
    class IntegerNode;
    using IntegerNodePtr = std::shared_ptr<IntegerNode>;
 
    class FloatNode;
    using FloatNodePtr = std::shared_ptr<FloatNode>;
 
    class Float32RegNode;
    using Float32RegNodePtr = std::shared_ptr<Float32RegNode>;
 
    class Float64RegNode;
    using Float64RegNodePtr = std::shared_ptr<Float64RegNode>;
 
    class FloatRegNode;
    using FloatRegNodePtr = std::shared_ptr<FloatRegNode>;
 
    class IntRegNode;
    using IntRegNodePtr = std::shared_ptr<IntRegNode>;
 
    class SelectorNode;
    using SelectorNodePtr = std::shared_ptr<SelectorNode>;
 
    class EnumEntryNode;
    using EnumEntryNodePtr = std::shared_ptr<EnumEntryNode>;
 
    class CommandNode;
    using CommandNodePtr = std::shared_ptr<CommandNode>;
 
    class Int32RegNode;
    using Int32RegNodePtr = std::shared_ptr<Int32RegNode>;
 
    class Int64RegNode;
    using Int64RegNodePtr = std::shared_ptr<Int64RegNode>;
 
    class EnumerationNode;
    using EnumerationNodePtr = std::shared_ptr<EnumerationNode>;
 
    class IntSwissKnifeNode;
    using IntSwissKnifeNodePtr = std::shared_ptr<IntSwissKnifeNode>;
 
    class ChunkIntRegNode;
    using ChunkIntRegNodePtr = std::shared_ptr<ChunkIntRegNode>;
 
    class ChunkFloatRegNode;
    using ChunkFloatRegNodePtr = std::shared_ptr<ChunkFloatRegNode>;
 
    enum class ServerInitType
    {
      FixedSize   = CExports::GSSI_FixedSize,
      DynamicSize = CExports::GSSI_DynamicSize
    };

    enum class DriverType
    {
      Auto   = CExports::DT_Auto,    
      Socket = CExports::DT_Socket,  
      Filter = CExports::DT_Filter   
    };

    enum class SendStatus
    {
      Ok = CExports::GVGSSS_SendOk,
      Timeout = CExports::GVGSSS_Timeout,
      WaitResend = CExports::GVGSSS_WaitResend,
      Abort = CExports::GVGSSS_SendAbort
    };
 
    enum class ServerEvent
    {
      Connected        = CExports::SE_Connected,
      Disconnected     = CExports::SE_Disconnected,
      AcquisitionStart = CExports::SE_AcquisitionStart,
      AcquisitionStop  = CExports::SE_AcquisitionStop,
      ImageSnapped     = CExports::SE_ImageSnapped
    };

    enum class Namespace
    {
      Standard = CExports::GSNS_Standard,  
      Custom   = CExports::GSNS_Custom,    
      Private  = CExports::GSNS_Private    
    };

    enum class NodeEvent
    {
      Read  = CExports::GSNE_Read,  
      Write = CExports::GSNE_Write  
    };

    enum class NodeType
    {
      Invalid       = CExports::GSNT_Invalid,        
      Unknown       = CExports::GSNT_Unknown,        
      Category      = CExports::GSNT_Category,       
      IntReg        = CExports::GSNT_IntReg,         
      StringReg     = CExports::GSNT_StringReg,      
      String        = CExports::GSNT_String,         
      Integer       = CExports::GSNT_Integer,        
      Boolean       = CExports::GSNT_Boolean,        
      Command       = CExports::GSNT_Command,        
      Enumeration   = CExports::GSNT_Enumeration,    
      EnumEntry     = CExports::GSNT_EnumEntry,      
      IntSwissKnife = CExports::GSNT_IntSwissKnife,  
      Float         = CExports::GSNT_Float,          
      FloatReg      = CExports::GSNT_FloatReg        
    };

    enum class Info
    {
      XMLVersionMajor    = CExports::GSI_XMLVersionMajor,     
      XMLVersionMinor    = CExports::GSI_XMLVersionMinor,     
      XMLVersionSubMinor = CExports::GSI_XMLVersionSubMinor,  
      ServerUserVersion  = CExports::GSI_ServerUserVersion,   
      AcquisitionActive  = CExports::GSI_AcquisitionActive    
    };

    enum class NodeInfo
    {
      Name            = CExports::GSNI_Name,             
      DisplayName     = CExports::GSNI_DisplayName,      
      AccessMode      = CExports::GSNI_AccessMode,       
      Max             = CExports::GSNI_Max,              
      Min             = CExports::GSNI_Min,              
      Increment       = CExports::GSNI_Increment,        
      NumEnumEntries  = CExports::GSNI_NumEnumEntries,   
      Streamable      = CExports::GSNI_Streamable,       
      CachingMode     = CExports::GSNI_CachingMode,      
      ToolTip         = CExports::GSNI_Tooltip,          
      Description     = CExports::GSNI_Description,      
      Visibility      = CExports::GSNI_Visibility,       
      PollingTime     = CExports::GSNI_PollingTime,      
      EventID         = CExports::GSNI_EventID,          
      NameSpace       = CExports::GSNI_Namespace,        
      RegisterLength  = CExports::GSNI_RegisterLength,   
      RegisterAddress = CExports::GSNI_RegisterAddress,  
      NumberRepresentation = CExports::GSNI_NumberRepresentation,  
      Value                = CExports::GSNI_Value,                 
      OnValue              = CExports::GSNI_OnValue,  
      OffValue          = CExports::GSNI_OffValue,    
      Formula           = CExports::GSNI_Formula,     
      ImposedAccessMode = CExports::GSNI_ImposedAccessMode,  
      IsImplemented =
          CExports::GSNI_IsImplemented,          
      IsAvailable = CExports::GSNI_IsAvailable,  
      IsLocked    = CExports::GSNI_IsLocked,     
      Alias       = CExports::GSNI_Alias,        
      Sign        = CExports::GSNI_Sign,         
      Unit        = CExports::GSNI_Unit,         
      DisplayPrecision =
          CExports::GSNI_DisplayPrecision,  
      Length = CExports::GSNI_RegisterLength, 
      Last = CExports::GSNI_Last            
    };

    enum class NumberRepresentation
    {
      None        = CExports::GSNR_None,         
      Linear      = CExports::GSNR_Linear,       
      Logarithmic = CExports::GSNR_Logarithmic,  
      Boolean     = CExports::GSNR_Boolean,      
      PureNumber  = CExports::GSNR_PureNumber,   
      HexNumber   = CExports::GSNR_HexNumber     
    };

    enum class NumberSign
    {
      Unsigned = CExports::GSNS_Unsigned,  
      Signed   = CExports::GSNS_Signed     
    };

    enum class NodeList
    {
      Child = CExports::GSNL_Child,              
      Selected    = CExports::GSNL_Selected,     
      Invalidator = CExports::GSNL_Invalidator,  
      Addresses   = CExports::GSNL_Addresses     
    };

    enum class PayloadType
    {
      Image      = CExports::GSPT_Image,      
      File       = CExports::GSPT_File,       
      ChunkImage = CExports::GSPT_ChunkImage  
    };
 
    enum class PixelFormat
    {
      Mono8  = CExports::GSPF_Mono8,
      Mono10 = CExports::GSPF_Mono10,
      Mono12 = CExports::GSPF_Mono12,
      Mono14 = CExports::GSPF_Mono14,
      Mono16 = CExports::GSPF_Mono16,
      RGB8   = CExports::GSPF_RGB8,
      BGR8   = CExports::GSPF_BGR8,
      RGBA8  = CExports::GSPF_RGBA8,
      BGRA8  = CExports::GSPF_BGRA8
    };
  }  // namespace GevServer
 
  CVB_END_INLINE_NS
}  // namespace Cvb