GEV Server (CVGevServer.dll) 14.0
GenApi Feature Functions

Functions

GSNODE CreateGSBooleanNode (const char *NodeName, TGSNamespace Namespace)
 Creates a boolean node with the given NodeName as C string in the given Namespace which can be used to map arbitrary values in an integer node. More...
 
GSNODE CreateGSBooleanNodeW (const wchar_t *NodeName, TGSNamespace Namespace)
 Creates a boolean node with the given NodeName as wide C string in the given Namespace which can be used to map arbitrary values in an integer node. More...
 
GSNODE CreateGSCategoryNode (const char *NodeName, TGSNamespace Namespace)
 Creates a category node with the given NodeName as C string in the given Namespace. More...
 
GSNODE CreateGSCategoryNodeW (const wchar_t *NodeName, TGSNamespace Namespace)
 Creates a category node with the given NodeName as wide C string in the given Namespace. More...
 
GSNODE CreateGSCommandNode (const char *NodeName, TGSNamespace Namespace)
 Creates a command node with the given NodeName as C string in the given Namespace to start an prolonged execution in a device. More...
 
GSNODE CreateGSCommandNodeW (const wchar_t *NodeName, TGSNamespace Namespace)
 Creates a command node with the given NodeName as wide C string in the given Namespace to start an prolonged execution in a device. More...
 
GSNODE CreateGSEnumEntryNode (const char *NodeName, TGSNamespace Namespace)
 Creates an enumeration entry node with the given NodeName as C string in the given Namespace. More...
 
GSNODE CreateGSEnumEntryNodeW (const wchar_t *NodeName, TGSNamespace Namespace)
 Creates an enumeration entry node with the given NodeName as wide C string in the given Namespace. More...
 
GSNODE CreateGSEnumerationNode (const char *NodeName, TGSNamespace Namespace)
 Creates an enumeration node (GenApi IEnumeration) with the given NodeName as C string in the given Namespace. More...
 
GSNODE CreateGSEnumerationNodeW (const wchar_t *NodeName, TGSNamespace Namespace)
 Creates an enumeration node (GenApi IEnumeration) with the given NodeName as wide C string in the given Namespace. More...
 
GSNODE CreateGSFloat32Node (const char *NodeName, TGSNamespace Namespace, cvbint64_t Address)
 Creates a 32bit float node with the given NodeName as C string in the given Namespace. More...
 
GSNODE CreateGSFloat32NodeW (const wchar_t *NodeName, TGSNamespace Namespace, cvbint64_t Address)
 Creates a 32bit float node with the given NodeName as wide C string in the given Namespace. More...
 
GSNODE CreateGSFloat64Node (const char *NodeName, TGSNamespace Namespace, cvbint64_t Address)
 Creates a 64bit register float node with the given NodeName as C string in the given Namespace. More...
 
GSNODE CreateGSFloat64NodeW (const wchar_t *NodeName, TGSNamespace Namespace, cvbint64_t Address)
 Creates a 64bit register float node with the given NodeName as wide C string in the given Namespace. More...
 
GSNODE CreateGSFloatNode (const char *NodeName, TGSNamespace Namespace)
 Creates an float node which is not directly connected to a register (GenApi IFloat) with the given NodeName as C string in the given Namespace. More...
 
GSNODE CreateGSFloatNodeW (const wchar_t *NodeName, TGSNamespace Namespace)
 Creates an float node which is not directly connected to a register (GenApi IFloat) with the given NodeName as wide C string in the given Namespace. More...
 
GSNODE CreateGSFloatRegNode (const char *NodeName, TGSNamespace Namespace, cvbint64_t Address, cvbint64_t Length)
 Creates a variable sized float register node with the given NodeName as C string in the given Namespace. More...
 
GSNODE CreateGSFloatRegNodeW (const wchar_t *NodeName, TGSNamespace Namespace, cvbint64_t Address, cvbint64_t Length)
 Creates a variable sized float register node with the given NodeName as wide C string in the given Namespace. More...
 
GSNODE CreateGSInt32Node (const char *NodeName, TGSNamespace Namespace, cvbint64_t Address)
 Creates a 32bit integer node with the given NodeName as C string in the given Namespace. More...
 
GSNODE CreateGSInt32NodeW (const wchar_t *NodeName, TGSNamespace Namespace, cvbint64_t Address)
 Creates a 32bit integer node with the given NodeName as wide C string in the given Namespace. More...
 
GSNODE CreateGSInt64Node (const char *NodeName, TGSNamespace Namespace, cvbint64_t Address)
 Creates a 64bit register integer node with the given NodeName as C string in the given Namespace. More...
 
GSNODE CreateGSInt64NodeW (const wchar_t *NodeName, TGSNamespace Namespace, cvbint64_t Address)
 Creates a 64bit register integer node with the given NodeName as wide C string in the given Namespace. More...
 
GSNODE CreateGSIntegerNode (const char *NodeName, TGSNamespace Namespace)
 Creates an integer node which is not directly connected to a register (GenApi IInteger) with the given NodeName as C string in the given Namespace. More...
 
GSNODE CreateGSIntegerNodeW (const wchar_t *NodeName, TGSNamespace Namespace)
 Creates an integer node which is not directly connected to a register (GenApi IInteger) with the given NodeName as wide C string in the given Namespace. More...
 
GSNODE CreateGSIntRegNode (const char *NodeName, TGSNamespace Namespace, cvbint64_t Address, cvbint64_t Length)
 Creates a variable sized integer register node with the given NodeName as C string in the given Namespace. More...
 
GSNODE CreateGSIntRegNodeW (const wchar_t *NodeName, TGSNamespace Namespace, cvbint64_t Address, cvbint64_t Length)
 Creates a variable sized integer register node with the given NodeName as wide C string in the given Namespace. More...
 
GSNODE CreateGSIntSwissKnifeNode (const char *NodeName, TGSNamespace Namespace)
 Creates a integer swiss knife node with the given NodeName as C string in the given Namespace. More...
 
GSNODE CreateGSIntSwissKnifeNodeW (const wchar_t *NodeName, TGSNamespace Namespace)
 Creates a integer swiss knife node with the given NodeName as wide C string in the given Namespace. More...
 
GSNODE CreateGSStringNode (const char *NodeName, TGSNamespace Namespace, cvbint64_t Address, cvbint64_t Length)
 Creates a string registry node with the given NodeName as C string in the given Namespace. More...
 
GSNODE CreateGSStringNodeEx (const char *NodeName, TGSNamespace Namespace)
 Creates a string node with the given NodeName as C string in the given Namespace. More...
 
GSNODE CreateGSStringNodeW (const wchar_t *NodeName, TGSNamespace Namespace, cvbint64_t Address, cvbint64_t Length)
 Creates a string register node with the given NodeName as wide C string in the given Namespace. More...
 
GSNODE CreateGSStringNodeWEx (const wchar_t *NodeName, TGSNamespace Namespace)
 Creates a string node with the given NodeName as wide string in the given Namespace. More...
 
GSNODE CreateGSStringRegNode (const char *NodeName, TGSNamespace Namespace, cvbint64_t Address, cvbint64_t Length)
 Creates a string node with the given NodeName as C string in the given Namespace. More...
 
GSNODE CreateGSStringRegNodeW (const wchar_t *NodeName, TGSNamespace Namespace, cvbint64_t Address, cvbint64_t Length)
 Creates a string node with the given NodeName as wide C string in the given Namespace. More...
 
cvbres_t GSAddNode (GEVSRV Server, GSNODE Node)
 Adds the given Node to the Server register map. More...
 
cvbres_t GSGetNode (GEVSRV Server, const char *NodeName, GSNODE &Node)
 Gets the node from the Server with the given NodeName. More...
 
cvbres_t GSGetNodeW (GEVSRV Server, const wchar_t *NodeName, GSNODE &Node)
 Gets the node from the Server with the given NodeName. More...
 
cvbres_t GSNAddNode (GSNODE Node, TGSNodeList Cmd, GSNODE ToAdd)
 Adds the given ToAdd node to the given Node specified by the Cmd. Used for simple indexed lists. More...
 
cvbres_t GSNAddNodeEx (GSNODE Node, TGSNodeList Cmd, const char *Key, GSNODE ToAdd)
 Adds the given ToAdd node to the given Node to the location specified the Cmd and Key as C string. More...
 
cvbres_t GSNAddNodeExW (GSNODE Node, TGSNodeList Cmd, const wchar_t *Key, GSNODE ToAdd)
 Adds the given ToAdd node to the given Node to the location specified the Cmd and Key as wide C string. More...
 
cvbres_t GSNGetAsBoolean (GSNODE Node, cvbbool_t &Value)
 Gets the current value of the given Node as a boolean. More...
 
cvbres_t GSNGetAsFloat (GSNODE Node, double &Value)
 Gets the value of the given Node as a float. More...
 
cvbres_t GSNGetAsInteger (GSNODE Node, cvbint64_t &Value)
 Gets the value of the given Node as an integer. More...
 
cvbres_t GSNGetAsString (GSNODE Node, char *Value, size_t &ValueSize)
 Gets the value of the given Node as a C string. More...
 
cvbres_t GSNGetAsStringW (GSNODE Node, wchar_t *Value, size_t &ValueSize)
 Gets the value of the given Node as a wide C string. More...
 
cvbres_t GSNGetInfoAsFloat (GSNODE Node, TGSNodeInfo Cmd, double &Info)
 Gets an informational part of the given Node specified by the Cmd as a float. More...
 
cvbres_t GSNGetInfoAsInteger (GSNODE Node, TGSNodeInfo Cmd, cvbint64_t &Info)
 Gets an informational part of the given Node specified by the Cmd as an integer. More...
 
cvbres_t GSNGetInfoAsNode (GSNODE Node, TGSNodeInfo Cmd, GSNODE &ValueNode)
 Gets an informational part of the given Node specified by the Cmd as a GSNODE. More...
 
cvbres_t GSNGetInfoAsString (GSNODE Node, TGSNodeInfo Cmd, char *Info, size_t &Length)
 Gets an informational part of the given Node specified by the Cmd as C string. More...
 
cvbres_t GSNGetInfoAsStringW (GSNODE Node, TGSNodeInfo Cmd, wchar_t *Info, size_t &Length)
 Gets an informational part of the given Node specified by the Cmd as wide C string. More...
 
cvbres_t GSNGetNode (GSNODE Node, TGSNodeList Cmd, const char *NodeName, GSNODE &ChildNode)
 Gets the ChildNode from the given Node. More...
 
cvbres_t GSNGetNodeW (GSNODE Node, TGSNodeList Cmd, const wchar_t *NodeName, GSNODE &ChildNode)
 Gets the ChildNode from the given Node. More...
 
cvbres_t GSNList (GSNODE Node, TGSNodeList Cmd, size_t Index, char *EntryName, size_t &EntryLength)
 Gets the node name (EntryName) in the list defined by Cmd as C string. More...
 
cvbres_t GSNListCount (GSNODE Node, TGSNodeList Cmd, size_t &NodeCount)
 Gets the number of nodes in the list defined by Cmd. More...
 
cvbres_t GSNListEx (GSNODE Node, TGSNodeList Cmd, size_t Index, char *EntryName, size_t &EntryLength, char *KeyName, size_t &KeyLength)
 Gets the node (EntryName) and key (KeyName) as C string in the list defined by Cmd. More...
 
cvbres_t GSNListExW (GSNODE Node, TGSNodeList Cmd, size_t Index, wchar_t *EntryName, size_t &EntryLength, wchar_t *KeyName, size_t &KeyLength)
 Gets the node (EntryName) and key (KeyName) as wide C string in the list defined by Cmd. More...
 
cvbres_t GSNListW (GSNODE Node, TGSNodeList Cmd, size_t Index, wchar_t *EntryName, size_t &EntryLength)
 Gets the node name (EntryName) in the list defined by Cmd as wide C string. More...
 
cvbres_t GSNodeCount (GEVSRV Server, size_t &NodeCount)
 Gets the number of GenApi feature nodes known to the Server. More...
 
cvbres_t GSNodeList (GEVSRV Server, size_t Index, char *EntryName, size_t &EntryLength)
 Gets a node name (EntryName) as C string at the given Index. More...
 
cvbres_t GSNodeListW (GEVSRV Server, size_t Index, wchar_t *EntryName, size_t &EntryLength)
 Gets a node name (EntryName) as wide C string at the given Index. More...
 
cvbres_t GSNRegisterEvent (GSNODE Node, TGSNodeEvent EventID, TFGEVSrv Callback, void *pPrivate, size_t &CallbackID)
 Registers the given EventID on the given Node. More...
 
cvbres_t GSNRegisterEventWithStatus (GSNODE Node, TGSNodeEvent EventID, TFGEVSrvStatus Callback, void *pPrivate, size_t &CallbackID)
 Registers the given EventID on the given Node. More...
 
cvbres_t GSNRemoveNode (GSNODE Node, TGSNodeList Cmd, GSNODE ToRemove)
 Removes the given ToRemove node from the given Node. More...
 
cvbres_t GSNRemoveNodeEx (GSNODE Node, TGSNodeList Cmd, const char *Key)
 Removes the node identified by the given Key as C string from the given Node. More...
 
cvbres_t GSNRemoveNodeExW (GSNODE Node, TGSNodeList Cmd, const wchar_t *Key)
 Removes the node identified by the given Key as wide C string from the given Node. More...
 
cvbres_t GSNSetAsBoolean (GSNODE Node, cvbbool_t Value)
 Sets the value of the given Node as a boolean. More...
 
cvbres_t GSNSetAsFloat (GSNODE Node, double Value)
 Sets the value of the given Node as a float. More...
 
cvbres_t GSNSetAsInteger (GSNODE Node, cvbint64_t Value)
 Sets the value of the given Node as an integer. More...
 
cvbres_t GSNSetAsString (GSNODE Node, const char *Value)
 Sets the value of the given Node as a C string. More...
 
cvbres_t GSNSetAsStringW (GSNODE Node, const wchar_t *Value)
 Sets the value of the given Node as a wide C string. More...
 
cvbres_t GSNSetInfoAsFloat (GSNODE Node, TGSNodeInfo Cmd, double Info)
 Sets an informational part of the given Node specified by the Cmd as a float. More...
 
cvbres_t GSNSetInfoAsInteger (GSNODE Node, TGSNodeInfo Cmd, cvbint64_t Info)
 Sets an informational part of the given Node specified by the Cmd as an integer. More...
 
cvbres_t GSNSetInfoAsNode (GSNODE Node, TGSNodeInfo Cmd, GSNODE ValueNode)
 Sets an informational part of the given Node specified by the Cmd as a GSNODE. More...
 
cvbres_t GSNSetInfoAsString (GSNODE Node, TGSNodeInfo Cmd, const char *Info)
 Sets an informational part of the given Node specified by the Cmd as C string. More...
 
cvbres_t GSNSetInfoAsStringW (GSNODE Node, TGSNodeInfo Cmd, const wchar_t *Info)
 Sets an informational part of the given Node specified by the Cmd as wide C string. More...
 
cvbres_t GSNType (GSNODE Node, TGSNodeType &Type)
 Gets the feature type of the given Node. More...
 
cvbres_t GSNUnregisterEvent (GSNODE Node, TGSNodeEvent EventID, size_t CallbackID)
 Unregisters the given CallbackID from the given Node. More...
 
cvbres_t GSRemoveNode (GEVSRV Server, GSNODE Node)
 Removes the given Node from the Server register map. More...
 
cvbbool_t IsGSNode (GSNODE Node)
 Tries to check whether the given Node handle is a valid object. More...
 

Detailed Description

Function Documentation

◆ CreateGSBooleanNode()

GSNODE CreateGSBooleanNode ( const char *  NodeName,
TGSNamespace  Namespace 
)

Creates a boolean node with the given NodeName as C string in the given Namespace which can be used to map arbitrary values in an integer node.

The node needs to be added to a server before most of the operations on it are valid.

Attention
Call the ReleaseObject function on the returned handle if it is not needed anymore.
Parameters
[in]NodeNameC string Name of the node (Must start with a letter (a-z) and may contain numbers and the underscore '_').
[in]NamespaceNamespace the node should reside in.
Returns
GSNODE containing the node handle, nullptr on error (Use GSGetLastErrorString function for a human readable error description).
Supported platforms:
Win32
Win64
Linux
Related Topics:
GSAddNode, GSNGetInfoAsInteger, GSNSetInfoAsInteger, GSNGetInfoAsString, GSNSetInfoAsString, GSNGetInfoAsNode, GSNSetInfoAsNode, GSNGetAsBoolean, GSNSetAsBoolean
See the IBoolean section in the Theory of Operation chapter for more information.

◆ CreateGSBooleanNodeW()

GSNODE CreateGSBooleanNodeW ( const wchar_t *  NodeName,
TGSNamespace  Namespace 
)

Creates a boolean node with the given NodeName as wide C string in the given Namespace which can be used to map arbitrary values in an integer node.

Since
CVB 14.00.000

The node needs to be added to a server before most of the operations on it are valid.

Attention
Call the ReleaseObject function on the returned handle if it is not needed anymore.
Parameters
[in]NodeNameWide C string Name of the node (Must start with a letter (a-z) and may contain numbers and the underscore '_').
[in]NamespaceNamespace the node should reside in.
Returns
GSNODE containing the node handle, nullptr on error (Use GSGetLastErrorString function for a human readable error description).
Supported platforms:
Win32
Win64
Linux
Related Topics:
GSAddNode, GSNGetInfoAsInteger, GSNSetInfoAsInteger, GSNGetInfoAsStringW, GSNSetInfoAsStringW, GSNGetInfoAsNode, GSNSetInfoAsNode, GSNGetAsBoolean, GSNSetAsBoolean
See the IBoolean section in the Theory of Operation chapter for more information.

◆ CreateGSCategoryNode()

GSNODE CreateGSCategoryNode ( const char *  NodeName,
TGSNamespace  Namespace 
)

Creates a category node with the given NodeName as C string in the given Namespace.

The node needs to be added to a server before most of the operations on it are valid.

Attention
Call the ReleaseObject function on the returned handle if it is not needed anymore.
Parameters
[in]NodeNameName of the node as C string (Must start with a letter (a-z) and may contain numbers and the underscore '_').
[in]NamespaceNamespace the node should reside in.
Returns
GSNODE containing the node handle, nullptr on error (Use GSGetLastErrorString function for a human readable error description).
Supported platforms:
Win32
Win64
Linux
Related Topics:
GSAddNode, GSNGetInfoAsInteger, GSNSetInfoAsInteger, GSNGetInfoAsString, GSNSetInfoAsString, GSNGetInfoAsNode, GSNSetInfoAsNode
See the ICategory section in the Theory of Operation chapter for more information.
Examples:
Visual C++ - VC GevServer Example.

◆ CreateGSCategoryNodeW()

GSNODE CreateGSCategoryNodeW ( const wchar_t *  NodeName,
TGSNamespace  Namespace 
)

Creates a category node with the given NodeName as wide C string in the given Namespace.

Since
CVB 14.00.000

The node needs to be added to a server before most of the operations on it are valid.

Attention
Call the ReleaseObject function on the returned handle if it is not needed anymore.
Parameters
[in]NodeNameName of the node as wide C string (Must start with a letter (a-z) and may contain numbers and the underscore '_').
[in]NamespaceNamespace the node should reside in.
Returns
GSNODE containing the node handle, nullptr on error (Use GSGetLastErrorString function for a human readable error description).
Supported platforms:
Win32
Win64
Linux
Related Topics:
GSAddNode, GSNGetInfoAsInteger, GSNSetInfoAsInteger, GSNGetInfoAsString, GSNSetInfoAsString, GSNGetInfoAsNode, GSNSetInfoAsNode
See the ICategory section in the Theory of Operation chapter for more information.
Examples:
Visual C++ - VC GevServer Example.

◆ CreateGSCommandNode()

GSNODE CreateGSCommandNode ( const char *  NodeName,
TGSNamespace  Namespace 
)

Creates a command node with the given NodeName as C string in the given Namespace to start an prolonged execution in a device.

The node needs to be added to a server before most of the operations on it are valid.

Attention
Call the ReleaseObject function on the returned handle if it is not needed anymore.
Parameters
[in]NodeNameName of the node as C string (Must start with a letter (a-z) and may contain numbers and the underscore '_').
[in]NamespaceNamespace the node should reside in.
Returns
GSNODE containing the node handle, nullptr on error (Use GSGetLastErrorString function for a human readable error description).
Supported platforms:
Win32
Win64
Linux
Related Topics:
GSAddNode, GSNGetInfoAsInteger, GSNSetInfoAsInteger, GSNGetInfoAsString, GSNSetInfoAsString, GSNGetInfoAsNode, GSNSetInfoAsNode, GSNGetAsBoolean, GSNSetAsBoolean
See the ICommand section in the Theory of Operation chapter for more information

◆ CreateGSCommandNodeW()

GSNODE CreateGSCommandNodeW ( const wchar_t *  NodeName,
TGSNamespace  Namespace 
)

Creates a command node with the given NodeName as wide C string in the given Namespace to start an prolonged execution in a device.

Since
CVB 14.00.000

The node needs to be added to a server before most of the operations on it are valid.

Attention
Call the ReleaseObject function on the returned handle if it is not needed anymore.
Parameters
[in]NodeNameName of the node as wide C string (Must start with a letter (a-z) and may contain numbers and the underscore '_').
[in]NamespaceNamespace the node should reside in.
Returns
GSNODE containing the node handle, nullptr on error (Use GSGetLastErrorString function for a human readable error description).
Supported platforms:
Win32
Win64
Linux
Related Topics:
GSAddNode, GSNGetInfoAsInteger, GSNSetInfoAsInteger, GSNGetInfoAsStringW, GSNSetInfoAsStringW, GSNGetInfoAsNode, GSNSetInfoAsNode, GSNGetAsBoolean, GSNSetAsBoolean
See the ICommand section in the Theory of Operation chapter for more information

◆ CreateGSEnumEntryNode()

GSNODE CreateGSEnumEntryNode ( const char *  NodeName,
TGSNamespace  Namespace 
)

Creates an enumeration entry node with the given NodeName as C string in the given Namespace.

The node needs not to be added to the server, but only to the enumeration node which should use it.

Attention
Call the ReleaseObject function on the returned handle if it is not needed anymore.
Parameters
[in]NodeNameName of the node as C string (Must start with a letter (a-z) and may contain numbers and the underscore '_').
[in]NamespaceNamespace the node should reside in.
Returns
GSNODE containing the node handle; nullptr on error (Use GSGetLastErrorString function for a human readable error description).
Supported platforms:
Win32
Win64
Linux
Related Topics:
GSAddNode, GSNGetInfoAsInteger, GSNSetInfoAsInteger, GSNGetInfoAsString, GSNSetInfoAsString, GSNGetInfoAsNode, GSNSetInfoAsNode, GSNGetAsInteger, GSNSetAsInteger, GSNGetAsString, GSNSetAsString, CreateGSEnumerationNode
See the IEnumEntry section in the Theory of Operation chapter for more information.
Examples:
Visual C++ - VC GevServer Example
Sample code in Visual C++:
See CreateGSEnumerationNode function for an example.

◆ CreateGSEnumEntryNodeW()

GSNODE CreateGSEnumEntryNodeW ( const wchar_t *  NodeName,
TGSNamespace  Namespace 
)

Creates an enumeration entry node with the given NodeName as wide C string in the given Namespace.

Since
CVB 14.00.000

The node needs not to be added to the server, but only to the enumeration node which should use it.

Attention
Call the ReleaseObject function on the returned handle if it is not needed anymore.
Parameters
[in]NodeNameName of the node as wide C string (Must start with a letter (a-z) and may contain numbers and the underscore '_').
[in]NamespaceNamespace the node should reside in.
Returns
GSNODE containing the node handle; nullptr on error (Use GSGetLastErrorString function for a human readable error description).
Supported platforms:
Win32
Win64
Linux
Related Topics:
GSAddNode, GSNGetInfoAsInteger, GSNSetInfoAsInteger, GSNGetInfoAsStringW, GSNSetInfoAsStringW, GSNGetInfoAsNode, GSNSetInfoAsNode, GSNGetAsInteger, GSNSetAsInteger, GSNGetAsStringW, GSNSetAsStringW, CreateGSEnumerationNode
See the IEnumEntry section in the Theory of Operation chapter for more information.
Examples:
Visual C++ - VC GevServer Example
Sample code in Visual C++:
See CreateGSEnumerationNode function for an example.

◆ CreateGSEnumerationNode()

GSNODE CreateGSEnumerationNode ( const char *  NodeName,
TGSNamespace  Namespace 
)

Creates an enumeration node (GenApi IEnumeration) with the given NodeName as C string in the given Namespace.

The node needs to be added to a server before most of the operations on it are valid.

Attention
Call the ReleaseObject function on the returned handle if it is not needed anymore.
Parameters
[in]NodeNameName of the node as C string (Must start with a letter (a-z) and may contain numbers and the underscore '_').
[in]NamespaceNamespace the node should reside in.
Returns
GSNODE containing the node handle; nullptr on error (Use GSGetLastErrorString function for a human readable error description).
Supported platforms:
Win32
Win64
Linux
Related Topics:
GSAddNode, GSNGetInfoAsInteger, GSNSetInfoAsInteger, GSNGetInfoAsString, GSNSetInfoAsString, GSNGetInfoAsNode, GSNSetInfoAsNode, GSNGetAsInteger, GSNSetAsInteger, GSNGetAsString, GSNSetAsString, CreateGSEnumEntryNode
See the IEnumeration section in the Theory of Operation chapter for more information.
Examples:
Visual C++ - VC GevServer Example
Sample code in Visual C++:
This C++ example shows how to create an enumeration and add it to a server:
#include <iostream>
#include <vector>
#include <iCVGEVServer.h>
void PrintLastError()
{
size_t bufferSize = 0;
GSGetLastErrorString(nullptr, bufferSize);
if(nBufferSize == 0)
return; // nothing to print
std::vector buffer(bufferSize);
GSGetLastErrorString(&buffer[0], bufferSize);
std::cout << &buffer[0] << std::endl;
}
void AddEnumerationToServer(GEVSRV hServer)
{
// create enumeration...
if(hEnum == nullptr)
{
PrintLastError();
return;
}
// ...and add it to server
cvbres_t result = GSAddNode(hServer, hEnum);
if(result < 0)
{
PrintLastError();
ReleaseObject(hEnum);
return;
}
// create and add entry
if(hEntry == nullptr)
{
PrintLastError();
ReleaseObject(hEnum);
return;
}
result = GSNAddNode(hEnum, GSNL_Child, hEntry);
ReleaseObject(hEnum);
if(result < 0)
{
PrintLastError();
ReleaseObject(hEntry);
return;
}
// set integer value (symbolic is by default the name)
result = GSNSetInfoAsInteger(hEntry, GSNI_Value, 42);
if(result < 0)
PrintLastError();
ReleaseObject(hEntry);
}
cvbres_t GSGetLastErrorString(char *Error, size_t &Length)
Gets the last string describing the reason of the last error.
Definition: GevServerExports.cpp:1712
GSNODE CreateGSEnumEntryNode(const char *NodeName, TGSNamespace Namespace)
Creates an enumeration entry node with the given NodeName as C string in the given Namespace.
Definition: GevServerExports.cpp:4811
GSNODE CreateGSEnumerationNode(const char *NodeName, TGSNamespace Namespace)
Creates an enumeration node (GenApi IEnumeration) with the given NodeName as C string in the given Na...
Definition: GevServerExports.cpp:4664
cvbres_t GSAddNode(GEVSRV Server, GSNODE Node)
Adds the given Node to the Server register map.
Definition: GevServerExports.cpp:4349
cvbres_t GSNAddNode(GSNODE Node, TGSNodeList Cmd, GSNODE ToAdd)
Adds the given ToAdd node to the given Node specified by the Cmd. Used for simple indexed lists.
Definition: GevServerExports.cpp:8893
cvbres_t GSNSetInfoAsInteger(GSNODE Node, TGSNodeInfo Cmd, cvbint64_t Info)
Sets an informational part of the given Node specified by the Cmd as an integer.
Definition: GevServerExports.cpp:7088
void * GSNODE
Handle of a server GenApi Node object.
Definition: iCVGevServer.h:31
void * GEVSRV
Handle of a GEV Server object.
Definition: iCVGevServer.h:29
@ GSNI_Value
Accesses the value configuration.
Definition: iCVGevServer.h:144
@ GSNL_Child
Nodes are accessed as a child nodes.
Definition: iCVGevServer.h:185
@ GSNS_Custom
Node is custom creation and not standardized.
Definition: iCVGevServer.h:80

◆ CreateGSEnumerationNodeW()

GSNODE CreateGSEnumerationNodeW ( const wchar_t *  NodeName,
TGSNamespace  Namespace 
)

Creates an enumeration node (GenApi IEnumeration) with the given NodeName as wide C string in the given Namespace.

Since
CVB 14.00.000

The node needs to be added to a server before most of the operations on it are valid.

Attention
Call the ReleaseObject function on the returned handle if it is not needed anymore.
Parameters
[in]NodeNameName of the node as wide C string (Must start with a letter (a-z) and may contain numbers and the underscore '_').
[in]NamespaceNamespace the node should reside in.
Returns
GSNODE containing the node handle; nullptr on error (Use GSGetLastErrorString function for a human readable error description).
Supported platforms:
Win32
Win64
Linux
Related Topics:
GSAddNode, GSNGetInfoAsInteger, GSNSetInfoAsInteger, GSNGetInfoAsString, GSNSetInfoAsString, GSNGetInfoAsNode, GSNSetInfoAsNode, GSNGetAsInteger, GSNSetAsInteger, GSNGetAsString, GSNSetAsString, CreateGSEnumEntryNode
See the IEnumeration section in the Theory of Operation chapter for more information.
Examples:
Visual C++ - VC GevServer Example
Sample code in Visual C++:
This C++ example shows how to create an enumeration and add it to a server:
#include <iostream>
#include <vector>
#include <iCVGEVServer.h>
void PrintLastError()
{
size_t bufferSize = 0;
GSGetLastErrorString(nullptr, bufferSize);
if(nBufferSize == 0)
return; // nothing to print
std::vector buffer(bufferSize);
GSGetLastErrorString(&buffer[0], bufferSize);
std::cout << &buffer[0] << std::endl;
}
void AddEnumerationToServer(GEVSRV hServer)
{
// create enumeration...
if(hEnum == nullptr)
{
PrintLastError();
return;
}
// ...and add it to server
cvbres_t result = GSAddNode(hServer, hEnum);
if(result < 0)
{
PrintLastError();
ReleaseObject(hEnum);
return;
}
// create and add entry
if(hEntry == nullptr)
{
PrintLastError();
ReleaseObject(hEnum);
return;
}
result = GSNAddNode(hEnum, GSNL_Child, hEntry);
ReleaseObject(hEnum);
if(result < 0)
{
PrintLastError();
ReleaseObject(hEntry);
return;
}
// set integer value (symbolic is by default the name)
result = GSNSetInfoAsInteger(hEntry, GSNI_Value, 42);
if(result < 0)
PrintLastError();
ReleaseObject(hEntry);
}
GSNODE CreateGSEnumerationNodeW(const wchar_t *NodeName, TGSNamespace Namespace)
Creates an enumeration node (GenApi IEnumeration) with the given NodeName as wide C string in the giv...
Definition: GevServerExports.cpp:4767
GSNODE CreateGSEnumEntryNodeW(const wchar_t *NodeName, TGSNamespace Namespace)
Creates an enumeration entry node with the given NodeName as wide C string in the given Namespace.
Definition: GevServerExports.cpp:4856

◆ CreateGSFloat32Node()

GSNODE CreateGSFloat32Node ( const char *  NodeName,
TGSNamespace  Namespace,
cvbint64_t  Address 
)

Creates a 32bit float node with the given NodeName as C string in the given Namespace.

The node needs to be added to a server before most of the operations on it are valid.

Attention
Call the ReleaseObject function on the returned handle if it is not needed anymore.
Parameters
[in]NodeNameName of the node as C string (Must start with a letter (a-z) and may contain numbers and the underscore '_').
[in]NamespaceNamespace the node should reside in.
[in]AddressAddress in the register map; -1 for auto-address. Must be a multiple of four.
Returns
GSNODE containing the node handle, nullptr on error (Use GSGetLastErrorString function for a human readable error description).
Supported platforms:
Win32
Win64
Linux
Related Topics:
GSAddNode, GSNGetInfoAsFloat, GSNSetInfoAsFloat, GSNGetInfoAsString, GSNSetInfoAsString, GSNGetInfoAsNode, GSNSetInfoAsNode, GSNGetAsFloat, GSNSetAsFloat, CreateGSFloat64Node, CreateGSFloatNode
See the IFLoatReg section in the Theory of Operation chapter for more information.

◆ CreateGSFloat32NodeW()

GSNODE CreateGSFloat32NodeW ( const wchar_t *  NodeName,
TGSNamespace  Namespace,
cvbint64_t  Address 
)

Creates a 32bit float node with the given NodeName as wide C string in the given Namespace.

Since
CVB 14.00.000

The node needs to be added to a server before most of the operations on it are valid.

Attention
Call the ReleaseObject function on the returned handle if it is not needed anymore.
Parameters
[in]NodeNameName of the node as wide C string (Must start with a letter (a-z) and may contain numbers and the underscore '_').
[in]NamespaceNamespace the node should reside in.
[in]AddressAddress in the register map; -1 for auto-address. Must be a multiple of four.
Returns
GSNODE containing the node handle, nullptr on error (Use GSGetLastErrorString function for a human readable error description).
Supported platforms:
Win32
Win64
Linux
Related Topics:
GSAddNode, GSNGetInfoAsFloat, GSNSetInfoAsFloat, GSNGetInfoAsStringW, GSNSetInfoAsStringW, GSNGetInfoAsNode, GSNSetInfoAsNode, GSNGetAsFloat, GSNSetAsFloat, CreateGSFloat64Node, CreateGSFloatNode
See the IFLoatReg section in the Theory of Operation chapter for more information.

◆ CreateGSFloat64Node()

GSNODE CreateGSFloat64Node ( const char *  NodeName,
TGSNamespace  Namespace,
cvbint64_t  Address 
)

Creates a 64bit register float node with the given NodeName as C string in the given Namespace.

The node needs to be added to a server before most of the operations on it are valid.

Attention
Call the ReleaseObject function on the returned handle if it is not needed anymore.
Parameters
[in]NodeNameName of the node as C string (Must start with a letter (a-z) and may contain numbers and the underscore '_').
[in]NamespaceNamespace the node should reside in.
[in]AddressAddress in the register map; -1 for auto-address. Must be a multiple of four.
Returns
GSNODE containing the node handle, nullptr on error (Use GSGetLastErrorString function for a human readable error description).
Supported platforms:
Win32
Win64
Linux
Related Topics:
GSAddNode, GSNGetInfoAsFloat, GSNSetInfoAsFloat, GSNGetInfoAsString, GSNSetInfoAsString, GSNGetInfoAsNode, GSNSetInfoAsNode, GSNGetAsFloat, GSNSetAsFloat, CreateGSFloat32Node, CreateGSFloatNode
See the IFloatReg section in the Theory of Operation chapter for more information.

◆ CreateGSFloat64NodeW()

GSNODE CreateGSFloat64NodeW ( const wchar_t *  NodeName,
TGSNamespace  Namespace,
cvbint64_t  Address 
)

Creates a 64bit register float node with the given NodeName as wide C string in the given Namespace.

Since
CVB 14.00.000

The node needs to be added to a server before most of the operations on it are valid.

Attention
Call the ReleaseObject function on the returned handle if it is not needed anymore.
Parameters
[in]NodeNameName of the node as wide C string (Must start with a letter (a-z) and may contain numbers and the underscore '_').
[in]NamespaceNamespace the node should reside in.
[in]AddressAddress in the register map; -1 for auto-address. Must be a multiple of four.
Returns
GSNODE containing the node handle, nullptr on error (Use GSGetLastErrorString function for a human readable error description).
Supported platforms:
Win32
Win64
Linux
Related Topics:
GSAddNode, GSNGetInfoAsFloat, GSNSetInfoAsFloat, GSNGetInfoAsStringW, GSNSetInfoAsStringW, GSNGetInfoAsNode, GSNSetInfoAsNode, GSNGetAsFloat, GSNSetAsFloat, CreateGSFloat32Node, CreateGSFloatNode
See the IFloatReg section in the Theory of Operation chapter for more information.

◆ CreateGSFloatNode()

GSNODE CreateGSFloatNode ( const char *  NodeName,
TGSNamespace  Namespace 
)

Creates an float node which is not directly connected to a register (GenApi IFloat) with the given NodeName as C string in the given Namespace.

The node needs to be added to a server before most of the operations on it are valid.

Attention
Call the ReleaseObject function on the returned handle if it is not needed anymore.
Parameters
[in]NodeNameName of the node as C string (Must start with a letter (a-z) and may contain numbers and the underscore '_').
[in]NamespaceNamespace the node should reside in.
Returns
GSNODE containing the node handle; nullptr on error (Use GSGetLastErrorString function for a human readable error description).
Supported platforms:
Win32
Win64
Linux
Related Topics:
GSAddNode, GSNGetInfoAsFloat, GSNSetInfoAsFloat, GSNGetInfoAsString, GSNSetInfoAsString, GSNGetInfoAsNode, GSNSetInfoAsNode, GSNGetAsFloat, GSNSetAsFloat, CreateGSInt64Node
See the IFloatNode section in the Theory of Operation chapter for more information

◆ CreateGSFloatNodeW()

GSNODE CreateGSFloatNodeW ( const wchar_t *  NodeName,
TGSNamespace  Namespace 
)

Creates an float node which is not directly connected to a register (GenApi IFloat) with the given NodeName as wide C string in the given Namespace.

Since
CVB 14.00.000

The node needs to be added to a server before most of the operations on it are valid.

Attention
Call the ReleaseObject function on the returned handle if it is not needed anymore.
Parameters
[in]NodeNameName of the node as wide C string (Must start with a letter (a-z) and may contain numbers and the underscore '_').
[in]NamespaceNamespace the node should reside in.
Returns
GSNODE containing the node handle; nullptr on error (Use GSGetLastErrorString function for a human readable error description).
Supported platforms:
Win32
Win64
Linux
Related Topics:
GSAddNode, GSNGetInfoAsFloat, GSNSetInfoAsFloat, GSNGetInfoAsStringW, GSNSetInfoAsStringW, GSNGetInfoAsNode, GSNSetInfoAsNode, GSNGetAsFloat, GSNSetAsFloat, CreateGSInt64Node
See the IFloatNode section in the Theory of Operation chapter for more information

◆ CreateGSFloatRegNode()

GSNODE CreateGSFloatRegNode ( const char *  NodeName,
TGSNamespace  Namespace,
cvbint64_t  Address,
cvbint64_t  Length 
)

Creates a variable sized float register node with the given NodeName as C string in the given Namespace.

This function creates a freely addressable float register. This also means, that no register memory is allocated in the server backing register read/writes.

You can use such a node for e.g. aliasing other registers or implementing a selector register.

The node needs to be added to a server before most of the operations on it are valid.

Attention
Call the ReleaseObject function on the returned handle if it is not needed anymore.
Parameters
[in]NodeNameName of the node as C string (Must start with a letter (a-z) and may contain numbers and the underscore '_').
[in]NamespaceNamespace the node should reside in.
[in]AddressAddress in the register map; no auto-address. Must be a multiple of four.
[in]LengthLength of the string in bytes. Must be either four or eight.
Returns
GSNODE containing the node handle; nullptr on error (Use GSGetLastErrorString function for a human readable error description).
Supported platforms:
Win32
Win64
Linux
Related Topics:
GSAddNode, GSNGetInfoAsFloat, GSNSetInfoAsFloat, GSNGetInfoAsString, GSNSetInfoAsString, GSNGetInfoAsNode, GSNSetInfoAsNode, GSNGetAsString, GSNSetAsString
See the IStringReg section in the Theory of Operation chapter for more information.

◆ CreateGSFloatRegNodeW()

GSNODE CreateGSFloatRegNodeW ( const wchar_t *  NodeName,
TGSNamespace  Namespace,
cvbint64_t  Address,
cvbint64_t  Length 
)

Creates a variable sized float register node with the given NodeName as wide C string in the given Namespace.

Since
CVB 14.00.000

This function creates a freely addressable float register. This also means, that no register memory is allocated in the server backing register read/writes.

You can use such a node for e.g. aliasing other registers or implementing a selector register.

The node needs to be added to a server before most of the operations on it are valid.

Attention
Call the ReleaseObject function on the returned handle if it is not needed anymore.
Parameters
[in]NodeNameName of the node as wide C string (Must start with a letter (a-z) and may contain numbers and the underscore '_').
[in]NamespaceNamespace the node should reside in.
[in]AddressAddress in the register map; no auto-address. Must be a multiple of four.
[in]LengthLength of the string in bytes. Must be either four or eight.
Returns
GSNODE containing the node handle; nullptr on error (Use GSGetLastErrorString function for a human readable error description).
Supported platforms:
Win32
Win64
Linux
Related Topics:
GSAddNode, GSNGetInfoAsFloat, GSNSetInfoAsFloat, GSNGetInfoAsStringW, GSNSetInfoAsStringW, GSNGetInfoAsNode, GSNSetInfoAsNode, GSNGetAsString, GSNSetAsString
See the IStringReg section in the Theory of Operation chapter for more information.

◆ CreateGSInt32Node()

GSNODE CreateGSInt32Node ( const char *  NodeName,
TGSNamespace  Namespace,
cvbint64_t  Address 
)

Creates a 32bit integer node with the given NodeName as C string in the given Namespace.

The node needs to be added to a server before most of the operations on it are valid.

Attention
Call the ReleaseObject function on the returned handle if it is not needed anymore.
Parameters
[in]NodeNameName of the node as C string (Must start with a letter (a-z) and may contain numbers and the underscore '_').
[in]NamespaceNamespace the node should reside in.
[in]AddressAddress in the register map; -1 for auto-address. Must be a multiple of four.
Returns
GSNODE containing the node handle, nullptr on error (Use GSGetLastErrorString function for a human readable error description).
Supported platforms:
Win32
Win64
Linux
Related Topics:
GSAddNode, GSNGetInfoAsInteger, GSNSetInfoAsInteger, GSNGetInfoAsString, GSNSetInfoAsString, GSNGetInfoAsNode, GSNSetInfoAsNode, GSNGetAsInteger, GSNSetAsInteger, CreateGSInt64Node, CreateGSIntegerNode
See the IIntReg section in the Theory of Operation chapter for more information.
Examples:
Visual C++ - VC GevServer Example.

◆ CreateGSInt32NodeW()

GSNODE CreateGSInt32NodeW ( const wchar_t *  NodeName,
TGSNamespace  Namespace,
cvbint64_t  Address 
)

Creates a 32bit integer node with the given NodeName as wide C string in the given Namespace.

Since
CVB 14.00.000

The node needs to be added to a server before most of the operations on it are valid.

Attention
Call the ReleaseObject function on the returned handle if it is not needed anymore.
Parameters
[in]NodeNameName of the node as wide C string (Must start with a letter (a-z) and may contain numbers and the underscore '_').
[in]NamespaceNamespace the node should reside in.
[in]AddressAddress in the register map; -1 for auto-address. Must be a multiple of four.
Returns
GSNODE containing the node handle, nullptr on error (Use GSGetLastErrorString function for a human readable error description).
Supported platforms:
Win32
Win64
Linux
Related Topics:
GSAddNode, GSNGetInfoAsInteger, GSNSetInfoAsInteger, GSNGetInfoAsStringW, GSNSetInfoAsStringW, GSNGetInfoAsNode, GSNSetInfoAsNode, GSNGetAsInteger, GSNSetAsInteger, CreateGSInt64Node, CreateGSIntegerNode
See the IIntReg section in the Theory of Operation chapter for more information.
Examples:
Visual C++ - VC GevServer Example.

◆ CreateGSInt64Node()

GSNODE CreateGSInt64Node ( const char *  NodeName,
TGSNamespace  Namespace,
cvbint64_t  Address 
)

Creates a 64bit register integer node with the given NodeName as C string in the given Namespace.

The node needs to be added to a server before most of the operations on it are valid.

Attention
Call the ReleaseObject function on the returned handle if it is not needed anymore.
Parameters
[in]NodeNameName of the node as C string (Must start with a letter (a-z) and may contain numbers and the underscore '_').
[in]NamespaceNamespace the node should reside in.
[in]AddressAddress in the register map; -1 for auto-address. Must be a multiple of four.
Returns
GSNODE containing the node handle, nullptr on error (Use GSGetLastErrorString function for a human readable error description).
Supported platforms:
Win32
Win64
Linux
Related Topics:
GSAddNode, GSNGetInfoAsInteger, GSNSetInfoAsInteger, GSNGetInfoAsString, GSNSetInfoAsString, GSNGetInfoAsNode, GSNSetInfoAsNode, GSNGetAsInteger, GSNSetAsInteger, CreateGSInt32Node, CreateGSIntegerNode
See the IIntReg section in the Theory of Operation chapter for more information.

◆ CreateGSInt64NodeW()

GSNODE CreateGSInt64NodeW ( const wchar_t *  NodeName,
TGSNamespace  Namespace,
cvbint64_t  Address 
)

Creates a 64bit register integer node with the given NodeName as wide C string in the given Namespace.

Since
CVB 14.00.000

The node needs to be added to a server before most of the operations on it are valid.

Attention
Call the ReleaseObject function on the returned handle if it is not needed anymore.
Parameters
[in]NodeNameName of the node as wide C string (Must start with a letter (a-z) and may contain numbers and the underscore '_').
[in]NamespaceNamespace the node should reside in.
[in]AddressAddress in the register map; -1 for auto-address. Must be a multiple of four.
Returns
GSNODE containing the node handle, nullptr on error (Use GSGetLastErrorString function for a human readable error description).
Supported platforms:
Win32
Win64
Linux
Related Topics:
GSAddNode, GSNGetInfoAsInteger, GSNSetInfoAsInteger, GSNGetInfoAsStringW, GSNSetInfoAsStringW, GSNGetInfoAsNode, GSNSetInfoAsNode, GSNGetAsInteger, GSNSetAsInteger, CreateGSInt32Node, CreateGSIntegerNode
See the IIntReg section in the Theory of Operation chapter for more information.

◆ CreateGSIntegerNode()

GSNODE CreateGSIntegerNode ( const char *  NodeName,
TGSNamespace  Namespace 
)

Creates an integer node which is not directly connected to a register (GenApi IInteger) with the given NodeName as C string in the given Namespace.

The node needs to be added to a server before most of the operations on it are valid.

Attention
Call the ReleaseObject function on the returned handle if it is not needed anymore.
Parameters
[in]NodeNameName of the node as C string (Must start with a letter (a-z) and may contain numbers and the underscore '_').
[in]NamespaceNamespace the node should reside in.
Returns
GSNODE containing the node handle; nullptr on error (Use GSGetLastErrorString function for a human readable error description).
Supported platforms:
Win32
Win64
Linux
Related Topics:
GSAddNode, GSNGetInfoAsInteger, GSNSetInfoAsInteger, GSNGetInfoAsString, GSNSetInfoAsString, GSNGetInfoAsNode, GSNSetInfoAsNode, GSNGetAsInteger, GSNSetAsInteger, CreateGSInt32Node, CreateGSInt64Node
See the IIntegerNode section in the Theory of Operation chapter for more information

◆ CreateGSIntegerNodeW()

GSNODE CreateGSIntegerNodeW ( const wchar_t *  NodeName,
TGSNamespace  Namespace 
)

Creates an integer node which is not directly connected to a register (GenApi IInteger) with the given NodeName as wide C string in the given Namespace.

Since
CVB 14.00.000

The node needs to be added to a server before most of the operations on it are valid.

Attention
Call the ReleaseObject function on the returned handle if it is not needed anymore.
Parameters
[in]NodeNameName of the node as wide C string (Must start with a letter (a-z) and may contain numbers and the underscore '_').
[in]NamespaceNamespace the node should reside in.
Returns
GSNODE containing the node handle; nullptr on error (Use GSGetLastErrorString function for a human readable error description).
Supported platforms:
Win32
Win64
Linux
Related Topics:
GSAddNode, GSNGetInfoAsInteger, GSNSetInfoAsInteger, GSNGetInfoAsStringW, GSNSetInfoAsStringW, GSNGetInfoAsNode, GSNSetInfoAsNode, GSNGetAsInteger, GSNSetAsInteger, CreateGSInt32Node, CreateGSInt64Node
See the IIntegerNode section in the Theory of Operation chapter for more information

◆ CreateGSIntRegNode()

GSNODE CreateGSIntRegNode ( const char *  NodeName,
TGSNamespace  Namespace,
cvbint64_t  Address,
cvbint64_t  Length 
)

Creates a variable sized integer register node with the given NodeName as C string in the given Namespace.

This function creates a freely addressable integer register. This also means, that no register memory is allocated in the server backing register read/writes.

You can use such a node for e.g. aliasing other registers or implementing a selector register.

The node needs to be added to a server before most of the operations on it are valid.

Attention
Call the ReleaseObject function on the returned handle if it is not needed anymore.
Parameters
[in]NodeNameName of the node as C string (Must start with a letter (a-z) and may contain numbers and the underscore '_').
[in]NamespaceNamespace the node should reside in.
[in]AddressAddress in the register map; no auto-address. Must be a multiple of four.
[in]LengthLength of the string in bytes. Must be either four or eight.
Returns
GSNODE containing the node handle; nullptr on error (Use GSGetLastErrorString function for a human readable error description).
Supported platforms:
Win32
Win64
Linux
Related Topics:
GSAddNode, GSNGetInfoAsInteger, GSNSetInfoAsInteger, GSNGetInfoAsString, GSNSetInfoAsString, GSNGetInfoAsNode, GSNSetInfoAsNode, GSNGetAsString, GSNSetAsString
See the IStringReg section in the Theory of Operation chapter for more information.

◆ CreateGSIntRegNodeW()

GSNODE CreateGSIntRegNodeW ( const wchar_t *  NodeName,
TGSNamespace  Namespace,
cvbint64_t  Address,
cvbint64_t  Length 
)

Creates a variable sized integer register node with the given NodeName as wide C string in the given Namespace.

Since
CVB 14.00.000

This function creates a freely addressable integer register. This also means, that no register memory is allocated in the server backing register read/writes.

You can use such a node for e.g. aliasing other registers or implementing a selector register.

The node needs to be added to a server before most of the operations on it are valid.

Attention
Call the ReleaseObject function on the returned handle if it is not needed anymore.
Parameters
[in]NodeNameName of the node as wide C string (Must start with a letter (a-z) and may contain numbers and the underscore '_').
[in]NamespaceNamespace the node should reside in.
[in]AddressAddress in the register map; no auto-address. Must be a multiple of four.
[in]LengthLength of the string in bytes. Must be either four or eight.
Returns
GSNODE containing the node handle; nullptr on error (Use GSGetLastErrorString function for a human readable error description).
Supported platforms:
Win32
Win64
Linux
Related Topics:
GSAddNode, GSNGetInfoAsInteger, GSNSetInfoAsInteger, GSNGetInfoAsStringW, GSNSetInfoAsStringW, GSNGetInfoAsNode, GSNSetInfoAsNode, GSNGetAsString, GSNSetAsString
See the IStringReg section in the Theory of Operation chapter for more information.

◆ CreateGSIntSwissKnifeNode()

GSNODE CreateGSIntSwissKnifeNode ( const char *  NodeName,
TGSNamespace  Namespace 
)

Creates a integer swiss knife node with the given NodeName as C string in the given Namespace.

Swiss-knifes are used to calculate values based on other integer nodes. The node needs to be added to a server before most of the operations on it are valid.

Attention
Call the ReleaseObject function on the returned handle if it is not needed anymore.
Parameters
[in]NodeNameName of the node as C string (Must start with a letter (a-z) and may contain numbers and the underscore '_').
[in]NamespaceNamespace the node should reside in.
Returns
GSNODE containing the node handle; nullptr on error (Use GSGetLastErrorString function for a human readable error description).
Supported platforms:
Win32
Win64
Linux
Related Topics:
GSAddNode, GSNGetInfoAsInteger, GSNSetInfoAsInteger, GSNGetInfoAsString, GSNSetInfoAsString, GSNGetInfoAsNode, GSNSetInfoAsNode, GSNGetAsInteger
See the IIntSwissKnife section in the Theory of Operation chapter for more information.
Sample in Visual C++:
This C++ example shows how to create an IntSwissKnife and add it to a server:
#include <iostream>
#include <vector>
#include <iCVGEVServer.h>
void PrintLastError()
{
size_t bufferSize = 0;
GSGetLastErrorString(nullptr, bufferSize);
if(bufferSize == 0)
return; // nothing to print
std::vector buffer(bufferSize);
GSGetLastErrorString(&buffer[0], bufferSize);
std::cout << &buffer[0] << std::endl;
}
void AddIntSwissKnifeToServer(GEVSRV hServer)
{
// create enumeration...
GSNODE hSwiss = CreateGSIntSwissKnifeNode("TestSwissKnife", GSNS_Custom);
if(hSwiss == nullptr)
{
PrintLastError();
return;
}
// ...and add it to server
cvbres_t result = GSAddNode(hServer, hSwiss);
if(result < 0)
{
PrintLastError();
ReleaseObject(hSwiss);
return;
}
// get nodes to reference in formula
GSNODE hWidth = nullptr;
result = GSGetNode(hServer, "Width", hWidth);
if(result < 0)
{
PrintLastError();
ReleaseObject(hSwiss);
return;
}
GSNODE hHeight = nullptr;
result = GSGetNode(hServer, "Height", hHeight);
if(result < 0)
{
PrintLastError();
ReleaseObject(hWidth);
ReleaseObject(hSwiss);
return;
}
// first add variables as formula set checks the validity of it
// (variable names must be capitalized)
result = GSNAddNodeEx(hSwiss, GSNL_Child, "WIDTH", hWidth);
cvbres_t result2 = GSNAddNodeEx(hSwiss, GSNL_Child, "HEIGHT", hHeight);
ReleaseObject(hWidth);
ReleaseObject(hHeight);
if(result < 0 || result2 < 0)
{
PrintLastError();
ReleaseObject(hSwiss);
return;
}
// set the formula
result = GSNSetInfoAsString(hSwiss, GSNI_Formula, "WIDTH * HEIGHT");
if(nResult < 0)
PrintLastError();
ReleaseObject(hSwiss);
}
cvbres_t GSNAddNodeEx(GSNODE Node, TGSNodeList Cmd, const char *Key, GSNODE ToAdd)
Adds the given ToAdd node to the given Node to the location specified the Cmd and Key as C string.
Definition: GevServerExports.cpp:9269
GSNODE CreateGSIntSwissKnifeNode(const char *NodeName, TGSNamespace Namespace)
Creates a integer swiss knife node with the given NodeName as C string in the given Namespace.
Definition: GevServerExports.cpp:5273
cvbres_t GSGetNode(GEVSRV Server, const char *NodeName, GSNODE &Node)
Gets the node from the Server with the given NodeName.
Definition: GevServerExports.cpp:4097
cvbres_t GSNSetInfoAsString(GSNODE Node, TGSNodeInfo Cmd, const char *Info)
Sets an informational part of the given Node specified by the Cmd as C string.
Definition: GevServerExports.cpp:8259
@ GSNI_Formula
Formula for SwissKnife nodes.
Definition: iCVGevServer.h:148

◆ CreateGSIntSwissKnifeNodeW()

GSNODE CreateGSIntSwissKnifeNodeW ( const wchar_t *  NodeName,
TGSNamespace  Namespace 
)

Creates a integer swiss knife node with the given NodeName as wide C string in the given Namespace.

Since
CVB 14.00.000

Swiss-knifes are used to calculate values based on other integer nodes. The node needs to be added to a server before most of the operations on it are valid.

Attention
Call the ReleaseObject function on the returned handle if it is not needed anymore.
Parameters
[in]NodeNameName of the node as wide C string (Must start with a letter (a-z) and may contain numbers and the underscore '_').
[in]NamespaceNamespace the node should reside in.
Returns
GSNODE containing the node handle; nullptr on error (Use GSGetLastErrorString function for a human readable error description).
Supported platforms:
Win32
Win64
Linux
Related Topics:
GSAddNode, GSNGetInfoAsInteger, GSNSetInfoAsInteger, GSNGetInfoAsStringW, GSNSetInfoAsStringW, GSNGetInfoAsNode, GSNSetInfoAsNode, GSNGetAsInteger
See the IIntSwissKnife section in the Theory of Operation chapter for more information.
Sample in Visual C++:
This C++ example shows how to create an IntSwissKnife and add it to a server:
#include <iostream>
#include <vector>
#include <iCVGEVServer.h>
void PrintLastError()
{
size_t bufferSize = 0;
GSGetLastErrorString(nullptr, bufferSize);
if(bufferSize == 0)
return; // nothing to print
std::vector buffer(bufferSize);
GSGetLastErrorString(&buffer[0], bufferSize);
std::cout << &buffer[0] << std::endl;
}
void AddIntSwissKnifeToServer(GEVSRV hServer)
{
// create enumeration...
GSNODE hSwiss = CreateGSIntSwissKnifeNodeW(L"TestSwissKnife", GSNS_Custom);
if(hSwiss == nullptr)
{
PrintLastError();
return;
}
// ...and add it to server
cvbres_t result = GSAddNode(hServer, hSwiss);
if(result < 0)
{
PrintLastError();
ReleaseObject(hSwiss);
return;
}
// get nodes to reference in formula
GSNODE hWidth = nullptr;
result = GSGetNode(hServer, "Width", hWidth);
if(result < 0)
{
PrintLastError();
ReleaseObject(hSwiss);
return;
}
GSNODE hHeight = nullptr;
result = GSGetNode(hServer, "Height", hHeight);
if(result < 0)
{
PrintLastError();
ReleaseObject(hWidth);
ReleaseObject(hSwiss);
return;
}
// first add variables as formula set checks the validity of it
// (variable names must be capitalized)
result = GSNAddNodeEx(hSwiss, GSNL_Child, "WIDTH", hWidth);
cvbres_t result2 = GSNAddNodeEx(hSwiss, GSNL_Child, "HEIGHT", hHeight);
ReleaseObject(hWidth);
ReleaseObject(hHeight);
if(result < 0 || result2 < 0)
{
PrintLastError();
ReleaseObject(hSwiss);
return;
}
// set the formula
result = GSNSetInfoAsString(hSwiss, GSNI_Formula, "WIDTH * HEIGHT");
if(nResult < 0)
PrintLastError();
ReleaseObject(hSwiss);
}
GSNODE CreateGSIntSwissKnifeNodeW(const wchar_t *NodeName, TGSNamespace Namespace)
Creates a integer swiss knife node with the given NodeName as wide C string in the given Namespace.
Definition: GevServerExports.cpp:5389

◆ CreateGSStringNode()

GSNODE CreateGSStringNode ( const char *  NodeName,
TGSNamespace  Namespace,
cvbint64_t  Address,
cvbint64_t  Length 
)

Creates a string registry node with the given NodeName as C string in the given Namespace.

The node needs to be added to a server before most of the operations on it are valid.

Attention
Call the ReleaseObject function on the returned handle if it is not needed anymore.
Parameters
[in]NodeNameName of the node as C string (Must start with a letter (a-z) and may contain numbers and the underscore '_').
[in]NamespaceNamespace the node should reside in.
[in]AddressAddress in the register map; -1 for auto-address. Must be a multiple of four.
[in]LengthLength of the string in bytes. Must be a multiple of four.
Returns
GSNODE containing the node handle; nullptr on error (Use GSGetLastErrorString function for a human readable error description).
Supported platforms:
Win32
Win64
Linux
Related Topics:
GSAddNode, GSNGetInfoAsInteger, GSNSetInfoAsInteger, GSNGetInfoAsString, GSNSetInfoAsString, GSNGetInfoAsNode, GSNSetInfoAsNode, GSNGetAsString, GSNSetAsString, CreateGSStringNodeEx, CreateGSStringRegNode
See the IStringReg section in the Theory of Operation chapter for more information.

◆ CreateGSStringNodeEx()

GSNODE CreateGSStringNodeEx ( const char *  NodeName,
TGSNamespace  Namespace 
)

Creates a string node with the given NodeName as C string in the given Namespace.

The node needs to be added to a server before most of the operations on it are valid.

Attention
Call the ReleaseObject function on the returned handle if it is not needed anymore.
Parameters
[in]NodeNameName of the node as wide C string (Must start with a letter (a-z) and may contain numbers and the underscore '_').
[in]NamespaceNamespace the node should reside in.
Returns
GSNODE containing the node handle; nullptr on error (Use GSGetLastErrorString function for a human readable error description).
Supported platforms:
Win32
Win64
Linux
Related Topics:
GSAddNode, GSNGetInfoAsInteger, GSNSetInfoAsInteger, GSNGetInfoAsStringW, GSNSetInfoAsStringW, GSNGetInfoAsNode, GSNSetInfoAsNode, GSNGetAsString, GSNSetAsString
See the IString section in the Theory of Operation chapter for more information.

◆ CreateGSStringNodeW()

GSNODE CreateGSStringNodeW ( const wchar_t *  NodeName,
TGSNamespace  Namespace,
cvbint64_t  Address,
cvbint64_t  Length 
)

Creates a string register node with the given NodeName as wide C string in the given Namespace.

Since
CVB 14.00.000

The node needs to be added to a server before most of the operations on it are valid.

Attention
Call the ReleaseObject function on the returned handle if it is not needed anymore.
Parameters
[in]NodeNameName of the node as wide C string (Must start with a letter (a-z) and may contain numbers and the underscore '_').
[in]NamespaceNamespace the node should reside in.
[in]AddressAddress in the register map; -1 for auto-address. Must be a multiple of four.
[in]LengthLength of the string in bytes. Must be a multiple of four.
Returns
GSNODE containing the node handle; nullptr on error (Use GSGetLastErrorString function for a human readable error description).
Supported platforms:
Win32
Win64
Linux
Related Topics:
GSAddNode, GSNGetInfoAsInteger, GSNSetInfoAsInteger, GSNGetInfoAsStringW, GSNSetInfoAsStringW, GSNGetInfoAsNode, GSNSetInfoAsNode, GSNGetAsString, GSNSetAsString, CreateGSStringNodeWEx, #CreateGSStringRegNodeWEx
See the IStringReg section in the Theory of Operation chapter for more information.

◆ CreateGSStringNodeWEx()

GSNODE CreateGSStringNodeWEx ( const wchar_t *  NodeName,
TGSNamespace  Namespace 
)

Creates a string node with the given NodeName as wide string in the given Namespace.

The node needs to be added to a server before most of the operations on it are valid.

Attention
Call the ReleaseObject function on the returned handle if it is not needed anymore.
Parameters
[in]NodeNameName of the node as wide C string (Must start with a letter (a-z) and may contain numbers and the underscore '_').
[in]NamespaceNamespace the node should reside in.
Returns
GSNODE containing the node handle; nullptr on error (Use GSGetLastErrorString function for a human readable error description).
Supported platforms:
Win32
Win64
Linux
Related Topics:
GSAddNode, GSNGetInfoAsInteger, GSNSetInfoAsInteger, GSNGetInfoAsStringW, GSNSetInfoAsStringW, GSNGetInfoAsNode, GSNSetInfoAsNode, GSNGetAsString, GSNSetAsString
See the IString section in the Theory of Operation chapter for more information.

◆ CreateGSStringRegNode()

GSNODE CreateGSStringRegNode ( const char *  NodeName,
TGSNamespace  Namespace,
cvbint64_t  Address,
cvbint64_t  Length 
)

Creates a string node with the given NodeName as C string in the given Namespace.

The node needs to be added to a server before most of the operations on it are valid.

Attention
Call the ReleaseObject function on the returned handle if it is not needed anymore.
Parameters
[in]NodeNameName of the node as C string (Must start with a letter (a-z) and may contain numbers and the underscore '_').
[in]NamespaceNamespace the node should reside in.
[in]AddressAddress in the register map; -1 for auto-address. Must be a multiple of four.
[in]LengthLength of the string in bytes. Must be a multiple of four.
Returns
GSNODE containing the node handle; nullptr on error (Use GSGetLastErrorString function for a human readable error description).
Supported platforms:
Win32
Win64
Linux
Related Topics:
GSAddNode, GSNGetInfoAsInteger, GSNSetInfoAsInteger, GSNGetInfoAsString, GSNSetInfoAsString, GSNGetInfoAsNode, GSNSetInfoAsNode, GSNGetAsString, GSNSetAsString
See the IStringReg section in the Theory of Operation chapter for more information.

◆ CreateGSStringRegNodeW()

GSNODE CreateGSStringRegNodeW ( const wchar_t *  NodeName,
TGSNamespace  Namespace,
cvbint64_t  Address,
cvbint64_t  Length 
)

Creates a string node with the given NodeName as wide C string in the given Namespace.

Since
CVB 14.00.000

The node needs to be added to a server before most of the operations on it are valid.

Attention
Call the ReleaseObject function on the returned handle if it is not needed anymore.
Parameters
[in]NodeNameName of the node as wide C string (Must start with a letter (a-z) and may contain numbers and the underscore '_').
[in]NamespaceNamespace the node should reside in.
[in]AddressAddress in the register map; -1 for auto-address. Must be a multiple of four.
[in]LengthLength of the string in bytes. Must be a multiple of four.
Returns
GSNODE containing the node handle; nullptr on error (Use GSGetLastErrorString function for a human readable error description).
Supported platforms:
Win32
Win64
Linux
Related Topics:
GSAddNode, GSNGetInfoAsInteger, GSNSetInfoAsInteger, GSNGetInfoAsStringW, GSNSetInfoAsStringW, GSNGetInfoAsNode, GSNSetInfoAsNode, GSNGetAsString, GSNSetAsString
See the IStringReg section in the Theory of Operation chapter for more information.

◆ GSAddNode()

cvbres_t GSAddNode ( GEVSRV  Server,
GSNODE  Node 
)

Adds the given Node to the Server register map.

This is possible as long as the Server is not started and no node with the same name is present.

Note
An added node is held by the Server. Even if all Node handles are released the node is still present until it is removed via GSRemoveNode.
Parameters
[in]ServerServer object to retrieve node from.
[in]NodeNode to add to the Server register map.
Returns
Smaller than zero on error (Use GSGetLastErrorString function for a human readable error description).
Supported platforms:
Win32
Win64
Linux
Related Topics:
CreateGevServer, CreateGevServerEx, GSNodeCount, GSNodeList, GSGetNode, GSRemoveNode, GSStartIPv4, CreateGSBooleanNode, CreateGSCategoryNode, CreateGSCommandNode, CreateGSEnumEntryNode, CreateGSEnumerationNode, CreateGSInt32Node, CreateGSInt64Node, CreateGSIntegerNode, CreateGSIntSwissKnifeNode, CreateGSStringNode
Examples:
Visual C++ - VC GevServer Example
Sample code in Visual C++:
For a source code example see the CreateGSEnumerationNode or CreateGSIntSwissKnifeNode functions.

◆ GSGetNode()

cvbres_t GSGetNode ( GEVSRV  Server,
const char *  NodeName,
GSNODE Node 
)

Gets the node from the Server with the given NodeName.

To enumerate all the node names known to the Server use the GSNodeList function.

Note
If the GSNODE object is in use the present handle is returned and shared (ShareObject function). Otherwise a new handle is created. Even if no handle is existent in the user application an added feature is still present in the server as long as it is not removed.
Attention
Call the ReleaseObject function on the returned handle if it is not needed anymore.
Parameters
[in]ServerServer object to retrieve node from.
[in]NodeNameName without namespace of the node to retrieve (zero-terminated).
[out]NodeHandle of the node with the given NodeName.
Returns
Smaller than zero on error (Use GSGetLastErrorString function for a human readable error description).
Supported platforms:
Win32
Win64
Related Topics:
GSNType, CreateGevServer, CreateGevServerEx, GSNodeCount, GSAddNode, GSNodeList, GSRemoveNode, GSStartIPv4
See the Feature Interfaces in the Theory of Operation chapter for a description on the different nodes.
Examples:
Visual C++ - VC GevServer Example
Sample code in Visual C++:
For a source code example see the CreateGSIntSwissKnifeNode function.

◆ GSGetNodeW()

cvbres_t GSGetNodeW ( GEVSRV  Server,
const wchar_t *  NodeName,
GSNODE Node 
)

Gets the node from the Server with the given NodeName.

Since
CVB 14.00.000

To enumerate all the node names known to the Server use the GSNodeList function.

Note
If the GSNODE object is in use the present handle is returned and shared (ShareObject function). Otherwise a new handle is created. Even if no handle is existent in the user application an added feature is still present in the server as long as it is not removed.
Attention
Call the ReleaseObject function on the returned handle if it is not needed anymore.
Parameters
[in]ServerServer object to retrieve node from.
[in]NodeNameName without namespace of the node to retrieve (zero-terminated).
[out]NodeHandle of the node with the given NodeName.
Returns
Smaller than zero on error (Use GSGetLastErrorString function for a human readable error description).
Supported platforms:
Win32
Win64
Related Topics:
GSNType, CreateGevServer, CreateGevServerEx, GSNodeCount, GSAddNode, GSNodeList, GSRemoveNode, GSStartIPv4
See the Feature Interfaces in the Theory of Operation chapter for a description on the different nodes.
Examples:
Visual C++ - VC GevServer Example
Sample code in Visual C++:
For a source code example see the CreateGSIntSwissKnifeNode function.

◆ GSNAddNode()

cvbres_t GSNAddNode ( GSNODE  Node,
TGSNodeList  Cmd,
GSNODE  ToAdd 
)

Adds the given ToAdd node to the given Node specified by the Cmd. Used for simple indexed lists.

Attention
This is only possible as long as the server has not been started.
Parameters
[in]NodeNode to add the other ToAdd node to.
[in]CmdWhere to add.
[in]ToAddNode to add.
Returns
Smaller than zero on error (Use GSGetLastErrorString function for a human readable error description).
Supported platforms:
Win32
Win64
Linux
Related Topics:
GSNRemoveNode, GSNRemoveNodeEx, GSGetNode, GSNGetNode, GSNAddNodeEx, GSNList, GSNListEx
Where a node can be added is documented in the #TGSNodeList type documentation.
See the Feature Interfaces in the Theory of Operation chapter for a description on the available node lists
Examples:
Visual C++ - VC GevServer Example
Sample in Visual C++:
See the CreateGSEnumerationNode function for an example.

◆ GSNAddNodeEx()

cvbres_t GSNAddNodeEx ( GSNODE  Node,
TGSNodeList  Cmd,
const char *  Key,
GSNODE  ToAdd 
)

Adds the given ToAdd node to the given Node to the location specified the Cmd and Key as C string.

Used for map-like lists which use keys to reference nodes.

Attention
This is only possible as long as the server has not been started.
Parameters
[in]NodeNode to add the other ToAdd node to.
[in]CmdWhere to add.
[in]KeyKey as C string which is e.g. a variable name for the node ToAdd.
[in]ToAddNode to add.
Returns
Smaller than zero on error (Use GSGetLastErrorString function for a human readable error description).
Supported platforms:
Win32
Win64
Linux
Related Topics:
GSNRemoveNode, GSNRemoveNodeEx, GSGetNode, GSNGetNode, GSNAddNode, GSNList, GSNListEx
Where a node can be added is documented in the #TGSNodeList type documentation.
See the Feature Interfaces in the Theory of Operation chapter for a description on the available node lists.
Examples:
Visual C++ - VC GevServer Example
Sample in Visual C++:
See the CreateGSIntSwissKnifeNode function for an example.

◆ GSNAddNodeExW()

cvbres_t GSNAddNodeExW ( GSNODE  Node,
TGSNodeList  Cmd,
const wchar_t *  Key,
GSNODE  ToAdd 
)

Adds the given ToAdd node to the given Node to the location specified the Cmd and Key as wide C string.

Since
CVB 14.00.000

Used for map-like lists which use keys to reference nodes.

Attention
This is only possible as long as the server has not been started.
Parameters
[in]NodeNode to add the other ToAdd node to.
[in]CmdWhere to add.
[in]KeyKey as wide C string which is e.g. a variable name for the node ToAdd.
[in]ToAddNode to add.
Returns
Smaller than zero on error (Use GSGetLastErrorString function for a human readable error description).
Supported platforms:
Win32
Win64
Linux
Related Topics:
GSNRemoveNode, GSNRemoveNodeEx, GSGetNode, GSNGetNode, GSNAddNode, GSNList, GSNListEx
Where a node can be added is documented in the #TGSNodeList type documentation.
See the Feature Interfaces in the Theory of Operation chapter for a description on the available node lists.
Examples:
Visual C++ - VC GevServer Example
Sample in Visual C++:
See the CreateGSIntSwissKnifeNode function for an example.

◆ GSNGetAsBoolean()

cvbres_t GSNGetAsBoolean ( GSNODE  Node,
cvbbool_t &  Value 
)

Gets the current value of the given Node as a boolean.

Only works on nodes implementing the IBoolean and ICommand GenApi interfaces.

Parameters
[in]NodeNode to query value from.
[out]ValueCurrent value of the Node; in case of a command this is the IsDone result if the command is readable.
Returns
Smaller than zero on error (Use GSGetLastErrorString function for a human readable error description).
Supported platforms:
Win32
Win64
Linux
Related Topics:
CreateGSBooleanNode, CreateGSCommandNode, GSNSetAsBoolean
See the IBoolean and ICommand sections in the Theory of Operation chapter for more information.

◆ GSNGetAsFloat()

cvbres_t GSNGetAsFloat ( GSNODE  Node,
double &  Value 
)

Gets the value of the given Node as a float.

Only works on nodes implementing the IFloat and IEnumeration GenApi interfaces.

Parameters
[in]NodeNode to query value from.
[out]ValueCurrent value of the Node.
Returns
Smaller than zero on error (Use GSGetLastErrorString function for a human readable error description).
Supported platforms:
Win32
Win64
Linux
Related Topics:
CreateGSEnumEntryNode, CreateGSEnumerationNode, CreateGSInt32Node, CreateGSInt64Node, CreateGSIntegerNode, CreateGSIntSwissKnifeNode, GSNSetAsFloat CreateGSFloatNode
See the IFloat section in the Theory of Operation chapter for more information.

◆ GSNGetAsInteger()

cvbres_t GSNGetAsInteger ( GSNODE  Node,
cvbint64_t &  Value 
)

Gets the value of the given Node as an integer.

Only works on nodes implementing the IInteger and IEnumeration GenApi interfaces.

Parameters
[in]NodeNode to query value from.
[out]ValueCurrent value of the Node.
Returns
Smaller than zero on error (Use GSGetLastErrorString function for a human readable error description).
Supported platforms:
Win32
Win64
Linux
Related Topics:
CreateGSEnumEntryNode, CreateGSEnumerationNode, CreateGSInt32Node, CreateGSInt64Node, CreateGSIntegerNode, CreateGSIntSwissKnifeNode, GSNSetAsInteger
See the IInteger section in the Theory of Operation chapter for more information.
Examples:
Visual C++ - VC GevServer Example

◆ GSNGetAsString()

cvbres_t GSNGetAsString ( GSNODE  Node,
char *  Value,
size_t &  ValueSize 
)

Gets the value of the given Node as a C string.

Only works on nodes implementing the IString and IEnumeration and IEnumEntry GenApi interfaces.

Parameters
[in]NodeNode to query value from.
[in]ValueIf not nullptr this is the C string buffer to be filled with the info; nullptr if size query is to be performed.
[in,out]ValueSizeSet with minimal buffer needed including zero-termination if Value is nullptr; if Value is not nullptr this is set to the minimal size of the Value buffer in bytes (including zero-termination).
Returns
Smaller than zero on error (Use GSGetLastErrorString function for a human readable error description).
Supported platforms:
Win32
Win64
Linux
Related Topics:
CreateGSEnumEntryNode, CreateGSEnumerationNode, CreateGSStringNode, GSNSetAsString
See the IStringReg, IEnumeration and IEnumEntry sections in the Theory of Operation chapter for more information.

◆ GSNGetAsStringW()

cvbres_t GSNGetAsStringW ( GSNODE  Node,
wchar_t *  Value,
size_t &  ValueSize 
)

Gets the value of the given Node as a wide C string.

Since
CVB 14.00.000

Only works on nodes implementing the IString and IEnumeration and IEnumEntry GenApi interfaces.

Parameters
[in]NodeNode to query value from.
[in]ValueIf not nullptr this is the wide C string buffer to be filled with the info; nullptr if size query is to be performed.
[in,out]ValueSizeSet with minimal buffer needed including zero-termination if Value is nullptr; if Value is not nullptr this is set to the minimal size of the Value buffer in bytes (including zero-termination).
Returns
Smaller than zero on error (Use GSGetLastErrorString function for a human readable error description).
Supported platforms:
Win32
Win64
Linux
Related Topics:
CreateGSEnumEntryNode, CreateGSEnumerationNode, CreateGSStringNode, GSNSetAsString
See the IStringReg, IEnumeration and IEnumEntry sections in the Theory of Operation chapter for more information.

◆ GSNGetInfoAsFloat()

cvbres_t GSNGetInfoAsFloat ( GSNODE  Node,
TGSNodeInfo  Cmd,
double &  Info 
)

Gets an informational part of the given Node specified by the Cmd as a float.

Not every information can be queried as a float.

Parameters
[in]NodeNode to query information from.
[in]CmdInformation to query.
[out]InfoInformation queried as a float.
Returns
Smaller than zero on error (Use GSGetLastErrorString function for a human readable error description).
Supported platforms:
Win32
Win64
Linux
Related Topics:
CreateGSBooleanNode, CreateGSCategoryNode, CreateGSCommandNode, CreateGSEnumEntryNode, CreateGSEnumerationNode, CreateGSInt32Node, CreateGSInt64Node, CreateGSIntegerNode, CreateGSIntSwissKnifeNode, CreateGSStringNode, GSNSetInfoAsInteger, GSNGetInfoAsString, GSNSetInfoAsString, GSNGetInfoAsNode, GSNSetInfoAsNode, CreateGSFloatNode
Which information can be queried is documented in the #TGSNodeInfo type documentation.
See the Feature Interfaces in the Theory of Operation chapter for a list of available properties per type.

◆ GSNGetInfoAsInteger()

cvbres_t GSNGetInfoAsInteger ( GSNODE  Node,
TGSNodeInfo  Cmd,
cvbint64_t &  Info 
)

Gets an informational part of the given Node specified by the Cmd as an integer.

Not every information can be queried as an integer.

Parameters
[in]NodeNode to query information from.
[in]CmdInformation to query.
[out]InfoInformation queried as an integer.
Returns
Smaller than zero on error (Use GSGetLastErrorString function for a human readable error description).
Supported platforms:
Win32
Win64
Linux
Related Topics:
CreateGSBooleanNode, CreateGSCategoryNode, CreateGSCommandNode, CreateGSEnumEntryNode, CreateGSEnumerationNode, CreateGSInt32Node, CreateGSInt64Node, CreateGSIntegerNode, CreateGSIntSwissKnifeNode, CreateGSStringNode, GSNSetInfoAsInteger, GSNGetInfoAsString, GSNSetInfoAsString, GSNGetInfoAsNode, GSNSetInfoAsNode
Which information can be queried is documented in the #TGSNodeInfo type documentation.
See the Feature Interfaces in the Theory of Operation chapter for a list of available properties per type.

◆ GSNGetInfoAsNode()

cvbres_t GSNGetInfoAsNode ( GSNODE  Node,
TGSNodeInfo  Cmd,
GSNODE ValueNode 
)

Gets an informational part of the given Node specified by the Cmd as a GSNODE.

If a fixed value is set, this function will return CVC_ERROR(CVC_E_OK), but will set ValueNode to nullptr. Not every information can be queried as a GSNODE.

Parameters
[in]NodeNode to get info from.
[in]CmdType of information to get.
[out]ValueNodeReference to handle to receive the node for the given Cmd; nullptr if no node is set.
Returns
Smaller than zero on error (Use GSGetLastErrorString function for a human readable error description).
Supported platforms:
Win32
Win64
Linux
Related Topics:
CreateGSBooleanNode, CreateGSCategoryNode, CreateGSCommandNode, CreateGSEnumEntryNode, CreateGSEnumerationNode, CreateGSInt32Node, CreateGSInt64Node, CreateGSIntegerNode, CreateGSIntSwissKnifeNode, CreateGSStringNode, GSNGetInfoAsInteger, GSNSetInfoAsInteger, GSNGetInfoAsString, GSNSetInfoAsString, GSNSetInfoAsNode
Which information can be queried is documented in the #TGSNodeInfo type documentation.
See the Feature Interfaces in the Theory of Operation chapter for a list of available properties per type

◆ GSNGetInfoAsString()

cvbres_t GSNGetInfoAsString ( GSNODE  Node,
TGSNodeInfo  Cmd,
char *  Info,
size_t &  Length 
)

Gets an informational part of the given Node specified by the Cmd as C string.

Not every information can be queried as a string.

Parameters
[in]NodeNode to retrieve info about.
[in]CmdType of information to retrieve as C string
[in]InfoIf not nullptr this is the buffer to be filled with the info; nullptr if size query is to be performed.
[in,out]LengthSet with minimal buffer needed including zero-termination if Info is nullptr; if Info is not nullptr this is set to the minimal size of the Info buffer in bytes (including zero-termination).
Returns
Smaller than zero on error (Use GSGetLastErrorString function for a human readable error description).
Supported platforms:
Win32
Win64
Linux
Related Topics:
CreateGSBooleanNode, CreateGSCategoryNode, CreateGSCommandNode, CreateGSEnumEntryNode, CreateGSEnumerationNode, CreateGSFloatNode, CreateGSFloat32Node, CreateGSFloat64Node, CreateGSInt32Node, CreateGSInt64Node, CreateGSIntegerNode, CreateGSIntSwissKnifeNode, CreateGSStringNode, GSNGetInfoAsInteger, GSNSetInfoAsInteger, GSNGetInfoAsString, GSNSetInfoAsString, GSNSetInfoAsNode, GSNGetInfoAsFloat, GSNSetInfoAsFloat
Which information can be queried is documented in the #TGSNodeInfo type documentation.
See the Feature Interfaces in the Theory of Operation chapter for a list of available properties per type

◆ GSNGetInfoAsStringW()

cvbres_t GSNGetInfoAsStringW ( GSNODE  Node,
TGSNodeInfo  Cmd,
wchar_t *  Info,
size_t &  Length 
)

Gets an informational part of the given Node specified by the Cmd as wide C string.

Since
CVB 14.00.000

Not every information can be queried as a string.

Parameters
[in]NodeNode to retrieve info about.
[in]CmdType of information to retrieve as wide C string
[in]InfoIf not nullptr this is the buffer to be filled with the info; nullptr if size query is to be performed.
[in,out]LengthSet with minimal buffer needed including zero-termination if Info is nullptr; if Info is not nullptr this is set to the minimal size of the Info buffer in bytes (including zero-termination).
Returns
Smaller than zero on error (Use GSGetLastErrorString function for a human readable error description).
Supported platforms:
Win32
Win64
Linux
Related Topics:
CreateGSBooleanNode, CreateGSCategoryNode, CreateGSCommandNode, CreateGSEnumEntryNode, CreateGSEnumerationNode, CreateGSFloatNode, CreateGSFloat32Node, CreateGSFloat64Node, CreateGSInt32Node, CreateGSInt64Node, CreateGSIntegerNode, CreateGSIntSwissKnifeNode, CreateGSStringNode, GSNGetInfoAsInteger, GSNSetInfoAsInteger, GSNGetInfoAsString, GSNSetInfoAsString, GSNSetInfoAsNode, GSNGetInfoAsFloat, GSNSetInfoAsFloat
Which information can be queried is documented in the #TGSNodeInfo type documentation.
See the Feature Interfaces in the Theory of Operation chapter for a list of available properties per type

◆ GSNGetNode()

cvbres_t GSNGetNode ( GSNODE  Node,
TGSNodeList  Cmd,
const char *  NodeName,
GSNODE ChildNode 
)

Gets the ChildNode from the given Node.

This function is used for nodes which are not directly accessible from the general node map (like inline IEnumEntry nodes).

Attention
Call the ReleaseObject function on the returned handle if it is not needed anymore.
Parameters
[in]NodeNode to get ChildNode from.
[in]CmdList to get node from.
[in]NodeNameName of the node to retrieve as C string (dependent on Node).
[out]ChildNodeReference to be filled with node handle.
Returns
Smaller than zero on error (Use GSGetLastErrorString function for a human readable error description).
Supported platforms:
Win32
Win64
Linux
Related Topics:
GSNType, GSNAddNode, GSNRemoveNode, GSNRemoveNodeEx, GSNList, GSNListEx
Where a node can be queried is documented in the #TGSNodeList type documentation.
See the Feature Interfaces in the Theory of Operation chapter for a list of available types.
Examples:
Visual C++ - VC GevServer Example

◆ GSNGetNodeW()

cvbres_t GSNGetNodeW ( GSNODE  Node,
TGSNodeList  Cmd,
const wchar_t *  NodeName,
GSNODE ChildNode 
)

Gets the ChildNode from the given Node.

Since
CVB 14.00.000

This function is used for nodes which are not directly accessible from the general node map (like inline IEnumEntry nodes).

Attention
Call the ReleaseObject function on the returned handle if it is not needed anymore.
Parameters
[in]NodeNode to get ChildNode from.
[in]CmdList to get node from.
[in]NodeNameName of the node to retrieve as wide C string (dependent on Node).
[out]ChildNodeReference to be filled with node handle.
Returns
Smaller than zero on error (Use GSGetLastErrorString function for a human readable error description).
Supported platforms:
Win32
Win64
Linux
Related Topics:
GSNType, GSNAddNode, GSNRemoveNode, GSNRemoveNodeEx, GSNList, GSNListEx
Where a node can be queried is documented in the #TGSNodeList type documentation.
See the Feature Interfaces in the Theory of Operation chapter for a list of available types.
Examples:
Visual C++ - VC GevServer Example

◆ GSNList()

cvbres_t GSNList ( GSNODE  Node,
TGSNodeList  Cmd,
size_t  Index,
char *  EntryName,
size_t &  EntryLength 
)

Gets the node name (EntryName) in the list defined by Cmd as C string.

Used for simple indexed lists.

The number of entries of the list can be obtained by calling GSNListCount. The actual node handle can then be retrieved via the GSGetNode or GSNGetNode functions.

Parameters
[in]NodeNode of which a list is to be enumerated.
[in]CmdWhich list to enumerate.
[in]IndexZero-based index of node to retrieve.
[in]EntryNameBuffer to be filled with node name as C string; nullptr to inquire size.
[in,out]EntryLengthSize of EntryName in bytes; the minimal size in bytes if EntryName is nullptr.
Returns
Smaller than zero on error (Use GSGetLastErrorString function for a human readable error description).
Supported platforms:
Win32
Win64
Linux
Related Topics:
GSNListCount, GSNAddNode, GSNRemoveNode, GSNRemoveNodeEx, GSNGetNode, GSNListEx, GSGetNode
Where a node can be queried is documented in the #TGSNodeList type documentation.
See the Feature Interfaces in the Theory of Operation chapter for a description on the available node lists.

◆ GSNListCount()

cvbres_t GSNListCount ( GSNODE  Node,
TGSNodeList  Cmd,
size_t &  NodeCount 
)

Gets the number of nodes in the list defined by Cmd.

Parameters
[in]NodeNode of which a list is to be enumerated.
[in]CmdWhich list to enumerate.
[out]NodeCountNumber of nodes in the list.
Returns
Smaller than zero on error (Use GSGetLastErrorString function for a human readable error description).
Supported platforms:
Win32
Win64
Linux
Related Topics:
GSNList, GSNAddNode, GSNRemoveNode, GSNRemoveNodeEx, GSNGetNode, GSNListEx, GSGetNode
Where a node can be queried is documented in the #TGSNodeList type documentation.
See the Feature Interfaces in the Theory of Operation chapter for a description on the available node lists

◆ GSNListEx()

cvbres_t GSNListEx ( GSNODE  Node,
TGSNodeList  Cmd,
size_t  Index,
char *  EntryName,
size_t &  EntryLength,
char *  KeyName,
size_t &  KeyLength 
)

Gets the node (EntryName) and key (KeyName) as C string in the list defined by Cmd.

Used for map-like lists which use keys to reference nodes.

The number of entries of the list can be obtained by calling GSNListCount. The actual node handle can then be retrieved via the GSGetNode or GSNGetNode functions.

The key can be a variable name for e.g. SwissKnife nodes.

Parameters
[in]NodeNode of which a list is to be enumerated.
[in]CmdWhich list to enumerate.
[in]IndexZero-based index of node to retrieve.
[in]EntryNameBuffer to be filled with node name as C string; nullptr to inquire size.
[in,out]EntryLengthSize of EntryName in bytes; the minimal size in bytes if EntryName is nullptr.
[in]KeyNameBuffer to be filled with node key as C string; nullptr to inquire size.
[in,out]KeyLengthSize of KeyName in bytes; the minimal size in bytes if KeyName is nullptr.
Returns
Smaller than zero on error (Use GSGetLastErrorString function for a human readable error description).
Supported platforms:
Win32
Win64
Linux
Related Topics:
GSNList, GSNAddNode, GSNGetNode, GSNRemoveNode, GSNRemoveNodeEx, GSNListCount, GSGetNode
Where a node can be queried is documented in the #TGSNodeList type documentation.
See the Feature Interfaces in the Theory of Operation chapter for a description on the available node lists.

◆ GSNListExW()

cvbres_t GSNListExW ( GSNODE  Node,
TGSNodeList  Cmd,
size_t  Index,
wchar_t *  EntryName,
size_t &  EntryLength,
wchar_t *  KeyName,
size_t &  KeyLength 
)

Gets the node (EntryName) and key (KeyName) as wide C string in the list defined by Cmd.

Since
CVB 14.00.000

Used for map-like lists which use keys to reference nodes.

The number of entries of the list can be obtained by calling GSNListCount. The actual node handle can then be retrieved via the GSGetNode or GSNGetNode functions.

The key can be a variable name for e.g. SwissKnife nodes.

Parameters
[in]NodeNode of which a list is to be enumerated.
[in]CmdWhich list to enumerate.
[in]IndexZero-based index of node to retrieve.
[in]EntryNameBuffer to be filled with node name as wide C string; nullptr to inquire size.
[in,out]EntryLengthSize of EntryName in bytes; the minimal size in bytes if EntryName is nullptr.
[in]KeyNameBuffer to be filled with node key as wide C string; nullptr to inquire size.
[in,out]KeyLengthSize of KeyName in bytes; the minimal size in bytes if KeyName is nullptr.
Returns
Smaller than zero on error (Use GSGetLastErrorString function for a human readable error description).
Supported platforms:
Win32
Win64
Linux
Related Topics:
GSNList, GSNAddNode, GSNGetNode, GSNRemoveNode, GSNRemoveNodeEx, GSNListCount, GSGetNode
Where a node can be queried is documented in the #TGSNodeList type documentation.
See the Feature Interfaces in the Theory of Operation chapter for a description on the available node lists.

◆ GSNListW()

cvbres_t GSNListW ( GSNODE  Node,
TGSNodeList  Cmd,
size_t  Index,
wchar_t *  EntryName,
size_t &  EntryLength 
)

Gets the node name (EntryName) in the list defined by Cmd as wide C string.

Since
CVB 14.00.000

Used for simple indexed lists.

The number of entries of the list can be obtained by calling GSNListCount. The actual node handle can then be retrieved via the GSGetNode or GSNGetNode functions.

Parameters
[in]NodeNode of which a list is to be enumerated.
[in]CmdWhich list to enumerate.
[in]IndexZero-based index of node to retrieve.
[in]EntryNameBuffer to be filled with node name as wide C string; nullptr to inquire size.
[in,out]EntryLengthSize of EntryName in bytes; the minimal size in bytes if EntryName is nullptr.
Returns
Smaller than zero on error (Use GSGetLastErrorString function for a human readable error description).
Supported platforms:
Win32
Win64
Linux
Related Topics:
GSNListCount, GSNAddNode, GSNRemoveNode, GSNRemoveNodeEx, GSNGetNode, GSNListEx, GSGetNode
Where a node can be queried is documented in the #TGSNodeList type documentation.
See the Feature Interfaces in the Theory of Operation chapter for a description on the available node lists.

◆ GSNodeCount()

cvbres_t GSNodeCount ( GEVSRV  Server,
size_t &  NodeCount 
)

Gets the number of GenApi feature nodes known to the Server.

Parameters
[in]ServerServer to enumerate nodes on.
[out]NodeCountNumber of nodes stored in the server.
Returns
Smaller than zero on error (Use GSGetLastErrorString function for a human readable error description).
Supported platforms:
Win32
Win64
Linux
Related Topics:
CreateGevServer, CreateGevServerEx, GSGetNode, GSAddNode, GSNodeList, GSRemoveNode, GSStartIPv4

◆ GSNodeList()

cvbres_t GSNodeList ( GEVSRV  Server,
size_t  Index,
char *  EntryName,
size_t &  EntryLength 
)

Gets a node name (EntryName) as C string at the given Index.

The number of available nodes can be obtained by calling GSNodeCount. With the returned EntryName a node can be queried by calling GSGetNode.

Attention
The Index stays only stable until the next GSAddNode or GSRemoveNode. The name stays valid as long as the node is not removed.
Parameters
[in]ServerServer to enumerate nodes on.
[in]IndexZero-based index of the node to enumerate.
[in]EntryNameC string to receive the node name; nullptr to inquire name length in bytes including the zero-termination.
[in,out]EntryLengthSize of EntryName in bytes if not nullptr; If EntryName is nullptr this will contain the minimal amount of bytes to store the name including the zero-termination.
Returns
Smaller than zero on error (Use GSGetLastErrorString function for a human readable error description).
Supported platforms:
Win32
Win64
Linux
Related Topics:
CreateGevServer, CreateGevServerEx, GSNodeCount, GSGetNode, GSAddNode, GSNodeList, GSRemoveNode, GSStartIPv4

◆ GSNodeListW()

cvbres_t GSNodeListW ( GEVSRV  Server,
size_t  Index,
wchar_t *  EntryName,
size_t &  EntryLength 
)

Gets a node name (EntryName) as wide C string at the given Index.

Since
CVB 14.00.000

The number of available nodes can be obtained by calling GSNodeCount. With the returned EntryName a node can be queried by calling GSGetNode.

Attention
The Index stays only stable until the next GSAddNode or GSRemoveNode. The name stays valid as long as the node is not removed.
Parameters
[in]ServerServer to enumerate nodes on.
[in]IndexZero-based index of the node to enumerate.
[in]EntryNameWide C string to receive the node name; nullptr to inquire name length in bytes including the zero-termination.
[in,out]EntryLengthSize of EntryName in bytes if not nullptr; If EntryName is nullptr this will contain the minimal amount of bytes to store the name including the zero-termination.
Returns
Smaller than zero on error (Use GSGetLastErrorString function for a human readable error description).
Supported platforms:
Win32
Win64
Linux
Related Topics:
CreateGevServer, CreateGevServerEx, GSNodeCount, GSGetNode, GSAddNode, GSNodeList, GSRemoveNode, GSStartIPv4

◆ GSNRegisterEvent()

cvbres_t GSNRegisterEvent ( GSNODE  Node,
TGSNodeEvent  EventID,
TFGEVSrv  Callback,
void *  pPrivate,
size_t &  CallbackID 
)

Registers the given EventID on the given Node.

Attention
Keep the Node handle alive as long as the event is needed as the Callback is stored in the handle and not in the Server Node.
Parameters
[in]NodeNode to register event on.
[in]EventIDEvent type to get notified on.
[in]CallbackCallback function to call in case of EventID.
[in]pPrivatePointer to private data given as the Callback function's parameter (e.g. pointer to a class).
[out]CallbackIDNode and EventID wide unique callback ID used to unregister the Callback.
Returns
Smaller than zero on error (Use GSGetLastErrorString function for a human readable error description).
Supported platforms:
Win32
Win64
Linux
Related Topics:
CreateGSBooleanNode, CreateGSCategoryNode, CreateGSCommandNode, CreateGSEnumEntryNode, CreateGSEnumerationNode, CreateGSInt32Node, CreateGSInt64Node, CreateGSIntegerNode, CreateGSIntSwissKnifeNode, CreateGSStringNode, GSNUnregisterEvent
See the IValue section in the Theory of Operation chapter for more information.
Examples:
Visual C++ - VC GevServer Example

◆ GSNRegisterEventWithStatus()

cvbres_t GSNRegisterEventWithStatus ( GSNODE  Node,
TGSNodeEvent  EventID,
TFGEVSrvStatus  Callback,
void *  pPrivate,
size_t &  CallbackID 
)

Registers the given EventID on the given Node.

The difference to the GSNRegisterEvent function is that the Callback has an additional argument which references a status. With that status a callee can communicate an error to the remote client for read/write access.

As there can be multiple registered callees, best check the status before doing your own processing. If a status other than CVC_ERROR(CVC_E_OK) is set after all callees finished their processing, the value in the node map is rolled back and an appropriate error acknowledge is sent.

Attention
Keep the Node handle alive as long as the event is needed as the Callback is stored in the handle and not in the Server Node.
Parameters
[in]NodeNode to register event on.
[in]EventIDEvent type to get notified on.
[in]CallbackCallback function to call in case of EventID.
[in]pPrivatePointer to private data given as the Callback function's parameter (e.g. pointer to a class).
[out]CallbackIDNode and EventID wide unique callback ID used to unregister the Callback.
Returns
Smaller than zero on error (Use GSGetLastErrorString function for a human readable error description).
Supported platforms:
Win32
Win64
Linux
Related Topics:
CreateGSBooleanNode, CreateGSCategoryNode, CreateGSCommandNode, CreateGSEnumEntryNode, CreateGSEnumerationNode, CreateGSInt32Node, CreateGSInt64Node, CreateGSIntegerNode, CreateGSIntSwissKnifeNode, CreateGSStringNode, GSNUnregisterEvent
See the IValue section in the Theory of Operation chapter for more information.
Examples:
Visual C++ - VC GevServer Example

◆ GSNRemoveNode()

cvbres_t GSNRemoveNode ( GSNODE  Node,
TGSNodeList  Cmd,
GSNODE  ToRemove 
)

Removes the given ToRemove node from the given Node.

Used for simple indexed lists.

Attention
This is only possible as long as the server has not been started.
Parameters
[in]NodeNode to remove the other ToRemove node from.
[in]CmdWhere to remove from.
[in]ToRemoveNode to remove.
Returns
Smaller than zero on error (Use GSGetLastErrorString function for a human readable error description).
Supported platforms:
Win32
Win64
Linux
Related Topics:
GSNRemoveNodeEx, GSNAddNode, GSGetNode, GSNGetNode, GSNAddNodeEx, GSNList, GSNListEx
Where a node can be removed is documented in the #TGSNodeList type documentation.
See the Feature Interfaces in the Theory of Operation chapter for a description on the available node lists

◆ GSNRemoveNodeEx()

cvbres_t GSNRemoveNodeEx ( GSNODE  Node,
TGSNodeList  Cmd,
const char *  Key 
)

Removes the node identified by the given Key as C string from the given Node.

Used for map-like lists which use keys to reference nodes.

Attention
This is only possible as long as the server has not been started.
Parameters
[in]NodeNode to remove the other node from.
[in]CmdWhere to remove from.
[in]KeyIdentifying the node to remove as C string.
Returns
Smaller than zero on error (Use GSGetLastErrorString function for a human readable error description).
Supported platforms:
Win32
Win64
Linux
Related Topics:
GSNRemoveNode, GSNAddNode, GSGetNode, GSNGetNode, GSNAddNodeEx, GSNList, GSNListEx
Where a node can be removed is documented in the #TGSNodeList type documentation.
See the Feature Interfaces in the Theory of Operation chapter for a description on the available node lists.

◆ GSNRemoveNodeExW()

cvbres_t GSNRemoveNodeExW ( GSNODE  Node,
TGSNodeList  Cmd,
const wchar_t *  Key 
)

Removes the node identified by the given Key as wide C string from the given Node.

Since
CVB 14.00.000

Used for map-like lists which use keys to reference nodes.

Attention
This is only possible as long as the server has not been started.
Parameters
[in]NodeNode to remove the other node from.
[in]CmdWhere to remove from.
[in]KeyIdentifying the node to remove as wide C string.
Returns
Smaller than zero on error (Use GSGetLastErrorString function for a human readable error description).
Supported platforms:
Win32
Win64
Linux
Related Topics:
GSNRemoveNode, GSNAddNode, GSGetNode, GSNGetNode, GSNAddNodeEx, GSNList, GSNListEx
Where a node can be removed is documented in the #TGSNodeList type documentation.
See the Feature Interfaces in the Theory of Operation chapter for a description on the available node lists.

◆ GSNSetAsBoolean()

cvbres_t GSNSetAsBoolean ( GSNODE  Node,
cvbbool_t  Value 
)

Sets the value of the given Node as a boolean.

Only works on nodes implementing the IBoolean and ICommand GenApi interfaces.

Parameters
[in]NodeNode to set value to.
[in]ValueNew value of the Node.
Returns
Smaller than zero on error (Use GSGetLastErrorString function for a human readable error description).
Supported platforms:
Win32
Win64
Linux
Related Topics:
CreateGSBooleanNode, CreateGSCommandNode, GSNGetAsBoolean
See the IBoolean and ICommand sections in the Theory of Operation chapter for more information

◆ GSNSetAsFloat()

cvbres_t GSNSetAsFloat ( GSNODE  Node,
double  Value 
)

Sets the value of the given Node as a float.

Only works on nodes implementing the IFloat and IEnumeration GenApi interfaces.

Parameters
[in]NodeNode to set value to.
[in]ValueNew value of the Node.
Returns
Smaller than zero on error (Use GSGetLastErrorString function for a human readable error description).
Supported platforms:
Win32
Win64
Linux
Related Topics:
CreateGSEnumEntryNode, CreateGSEnumerationNode, CreateGSInt32Node, CreateGSInt64Node, CreateGSIntegerNode, CreateGSIntSwissKnifeNode, GSNGetAsFloat CreateGSFloatNode
See the IFloat section in the Theory of Operation chapter for more information

◆ GSNSetAsInteger()

cvbres_t GSNSetAsInteger ( GSNODE  Node,
cvbint64_t  Value 
)

Sets the value of the given Node as an integer.

Only works on nodes implementing the IInteger and IEnumeration GenApi interfaces.

Parameters
[in]NodeNode to set value to.
[in]ValueNew value of the Node.
Returns
Smaller than zero on error (Use GSGetLastErrorString function for a human readable error description).
Supported platforms:
Win32
Win64
Linux
Related Topics:
CreateGSEnumEntryNode, CreateGSEnumerationNode, CreateGSInt32Node, CreateGSInt64Node, CreateGSIntegerNode, CreateGSIntSwissKnifeNode, GSNGetAsInteger
See the IInteger section in the Theory of Operation chapter for more information
Examples:
Visual C++ - VC GevServer Example.

◆ GSNSetAsString()

cvbres_t GSNSetAsString ( GSNODE  Node,
const char *  Value 
)

Sets the value of the given Node as a C string.

Only works on nodes implementing the IString and IEnumeration and IEnumEntry GenApi interfaces.

Parameters
[in]NodeNode to set value to.
[in]ValueNew value of the Node as C string.
Returns
Smaller than zero on error (Use GSGetLastErrorString function for a human readable error description).
Supported platforms:
Win32
Win64
Linux
Related Topics:
CreateGSEnumEntryNode, CreateGSEnumerationNode, CreateGSStringNode, GSNGetAsString
See the IStringReg, IEnumeration and IEnumEntry sections in the Theory of Operation chapter for more information.

◆ GSNSetAsStringW()

cvbres_t GSNSetAsStringW ( GSNODE  Node,
const wchar_t *  Value 
)

Sets the value of the given Node as a wide C string.

Since
CVB 14.00.000

Only works on nodes implementing the IString and IEnumeration and IEnumEntry GenApi interfaces.

Parameters
[in]NodeNode to set value to.
[in]ValueNew value of the Node as wide C string.
Returns
Smaller than zero on error (Use GSGetLastErrorString function for a human readable error description).
Supported platforms:
Win32
Win64
Linux
Related Topics:
CreateGSEnumEntryNode, CreateGSEnumerationNode, CreateGSStringNode, GSNGetAsString
See the IStringReg, IEnumeration and IEnumEntry sections in the Theory of Operation chapter for more information.

◆ GSNSetInfoAsFloat()

cvbres_t GSNSetInfoAsFloat ( GSNODE  Node,
TGSNodeInfo  Cmd,
double  Info 
)

Sets an informational part of the given Node specified by the Cmd as a float.

Not every information can be set as a float. Set is only possible if the server has not been started yet. Also some information can only be set if the node is added to the register map.

Parameters
[in]NodeNode to set info in.
[in]CmdType of information to set.
[in]InfoInformation set as a float.
Returns
Smaller than zero on error (Use GSGetLastErrorString function for a human readable error description).
Supported platforms:
Win32
Win64
Linux
Related Topics:
CreateGSBooleanNode, CreateGSCategoryNode, CreateGSCommandNode, CreateGSEnumEntryNode, CreateGSEnumerationNode, CreateGSInt32Node, CreateGSInt64Node, CreateGSIntegerNode, CreateGSIntSwissKnifeNode, CreateGSStringNode, GSNGetInfoAsInteger, GSNGetInfoAsString, GSNSetInfoAsString, GSNGetInfoAsNode, GSNSetInfoAsNode, CreateGSFloatNode
Which information can be set is documented in the #TGSNodeInfo type documentation.
See the Feature Interfaces in the Theory of Operation chapter for a list of available properties per type

◆ GSNSetInfoAsInteger()

cvbres_t GSNSetInfoAsInteger ( GSNODE  Node,
TGSNodeInfo  Cmd,
cvbint64_t  Info 
)

Sets an informational part of the given Node specified by the Cmd as an integer.

Not every information can be set as an integer. Set is only possible if the server has not been started yet. Also some information can only be set if the node is added to the register map.

Parameters
[in]NodeNode to set info in.
[in]CmdType of information to set.
[in]InfoInformation set as an integer.
Returns
Smaller than zero on error (Use GSGetLastErrorString function for a human readable error description).
Supported platforms:
Win32
Win64
Linux
Related Topics:
CreateGSBooleanNode, CreateGSCategoryNode, CreateGSCommandNode, CreateGSEnumEntryNode, CreateGSEnumerationNode, CreateGSInt32Node, CreateGSInt64Node, CreateGSIntegerNode, CreateGSIntSwissKnifeNode, CreateGSStringNode, GSNGetInfoAsInteger, GSNGetInfoAsString, GSNSetInfoAsString, GSNGetInfoAsNode, GSNSetInfoAsNode
Which information can be set is documented in the #TGSNodeInfo type documentation.
See the Feature Interfaces in the Theory of Operation chapter for a list of available properties per type
Examples:
Visual C++ - VC GevServer Example
Sample in Visual C++:
For an example see the CreateGSEnumerationNode function.

◆ GSNSetInfoAsNode()

cvbres_t GSNSetInfoAsNode ( GSNODE  Node,
TGSNodeInfo  Cmd,
GSNODE  ValueNode 
)

Sets an informational part of the given Node specified by the Cmd as a GSNODE.

The given ValueNode must be of a compatible type to Node. This would be e.g. an IntRegNode for an IntegerNode. Not every information can be set as a node.

Parameters
[in]NodeNode to set info in.
[in]CmdType of information to set.
[out]ValueNodeNode handle of the node for the given Cmd.
Returns
Smaller than zero on error (Use GSGetLastErrorString function for a human readable error description).
Supported platforms:
Win32
Win64
Linux
Related Topics:
CreateGSBooleanNode, CreateGSCategoryNode, CreateGSCommandNode, CreateGSEnumEntryNode, CreateGSEnumerationNode, CreateGSInt32Node, CreateGSInt64Node, CreateGSIntegerNode, CreateGSIntSwissKnifeNode, CreateGSStringNode, GSNGetInfoAsInteger, GSNSetInfoAsInteger, GSNGetInfoAsString, GSNSetInfoAsString, GSNGetInfoAsNode
Which information can be set is documented in the #TGSNodeInfo type documentation.
See the Feature Interfaces in the Theory of Operation chapter for a list of available properties per type.
Examples:
Visual C++ - VC GevServer Example

◆ GSNSetInfoAsString()

cvbres_t GSNSetInfoAsString ( GSNODE  Node,
TGSNodeInfo  Cmd,
const char *  Info 
)

Sets an informational part of the given Node specified by the Cmd as C string.

Not every information can be set as a string. Set is only possible if the server has not been started yet. Also some information can only be set if the node is added to the register map.

Parameters
[in]NodeNode to set info in.
[in]CmdType of information to set as C string.
[in]InfoBuffer containing the new info to be set (zero terminated).
Returns
Smaller than zero on error (Use GSGetLastErrorString function for a human readable error description).
Supported platforms:
Win32
Win64
Linux
Related Topics:
CreateGSBooleanNode, CreateGSCategoryNode, CreateGSCommandNode, CreateGSEnumEntryNode, CreateGSEnumerationNode, CreateGSInt32Node, CreateGSInt64Node, CreateGSIntegerNode, CreateGSIntSwissKnifeNode, CreateGSStringNode, GSNGetInfoAsInteger, GSNSetInfoAsInteger, GSNGetInfoAsString, GSNGetInfoAsNode, GSNSetInfoAsNode
Which information can be set is documented in the #TGSNodeInfo type documentation.
See the Feature Interfaces in the Theory of Operation chapter for a list of available properties per type.
Examples:
Visual C++ - VC GevServer Example.
Sample in Visual C++:
For an example see the CreateGSIntSwissKnifeNode function.

◆ GSNSetInfoAsStringW()

cvbres_t GSNSetInfoAsStringW ( GSNODE  Node,
TGSNodeInfo  Cmd,
const wchar_t *  Info 
)

Sets an informational part of the given Node specified by the Cmd as wide C string.

Since
CVB 14.00.000

Not every information can be set as a string. Set is only possible if the server has not been started yet. Also some information can only be set if the node is added to the register map.

Parameters
[in]NodeNode to set info in.
[in]CmdType of information to set as wide C string.
[in]InfoBuffer containing the new info to be set (zero terminated).
Returns
Smaller than zero on error (Use GSGetLastErrorString function for a human readable error description).
Supported platforms:
Win32
Win64
Linux
Related Topics:
CreateGSBooleanNode, CreateGSCategoryNode, CreateGSCommandNode, CreateGSEnumEntryNode, CreateGSEnumerationNode, CreateGSInt32Node, CreateGSInt64Node, CreateGSIntegerNode, CreateGSIntSwissKnifeNode, CreateGSStringNode, GSNGetInfoAsInteger, GSNSetInfoAsInteger, GSNGetInfoAsString, GSNGetInfoAsNode, GSNSetInfoAsNode
Which information can be set is documented in the #TGSNodeInfo type documentation.
See the Feature Interfaces in the Theory of Operation chapter for a list of available properties per type.
Examples:
Visual C++ - VC GevServer Example.
Sample in Visual C++:
For an example see the CreateGSIntSwissKnifeNode function.

◆ GSNType()

cvbres_t GSNType ( GSNODE  Node,
TGSNodeType &  Type 
)

Gets the feature type of the given Node.

Parameters
[in]NodeNode to query.
[out]TypeType of feature.
Returns
Smaller than zero on error (Use GSGetLastErrorString function for a human readable error description).
Supported platforms:
Win32
Win64
Linux
Related Topics:
CreateGSBooleanNode, CreateGSCategoryNode, CreateGSCommandNode, CreateGSEnumEntryNode, CreateGSEnumerationNode, CreateGSInt32Node, CreateGSInt64Node, CreateGSIntegerNode, CreateGSIntSwissKnifeNode, CreateGSStringNode
For a list of available node type see the #TGSNodeType documentation.
See the Feature Interfaces in the Theory of Operation chapter for a list of types and their properties.

◆ GSNUnregisterEvent()

cvbres_t GSNUnregisterEvent ( GSNODE  Node,
TGSNodeEvent  EventID,
size_t  CallbackID 
)

Unregisters the given CallbackID from the given Node.

The previously registered callback function will not be called anymore.

Parameters
[in]NodeNode to unregister event on.
[in]EventIDType of event to unregister.
[in]CallbackIDID of callback function to unregister.
Returns
Smaller than zero on error (Use GSGetLastErrorString function for a human readable error description).
Supported platforms:
Win32
Win64
Linux
Related Topics:
CreateGSBooleanNode, CreateGSCategoryNode, CreateGSCommandNode, CreateGSEnumEntryNode, CreateGSEnumerationNode, CreateGSInt32Node, CreateGSInt64Node, CreateGSIntegerNode, CreateGSIntSwissKnifeNode, CreateGSStringNode, GSNRegisterEvent
See the IValue section in the Theory of Operation chapter for more information.

◆ GSRemoveNode()

cvbres_t GSRemoveNode ( GEVSRV  Server,
GSNODE  Node 
)

Removes the given Node from the Server register map.

This is possible as long as the Server is not started and a node with the same name is present.

Parameters
[in]ServerServer object to remove node from.
[in]NodeNode to remove from the Server register map.
Returns
Smaller than zero on error (Use GSGetLastErrorString function for a human readable error description).
Supported platforms:
Win32
Win64
Linux
Related Topics:
CreateGevServer, CreateGevServerEx, GSNodeCount, GSAddNode, GSNodeList, GSGetNode, GSStartIPv4

◆ IsGSNode()

cvbbool_t IsGSNode ( GSNODE  Node)

Tries to check whether the given Node handle is a valid object.

Attention
Always use initialized variables and initialize unused handles with nullptr.
Parameters
[in]NodeNode handle to check.
Returns
TRUE if it is a valid object, FALSE otherwise.
Supported platforms:
Win32
Win64
Linux
Related Topics:
CreateGSBooleanNode, CreateGSCategoryNode, CreateGSCommandNode, CreateGSEnumEntryNode, CreateGSEnumerationNode, CreateGSInt32Node, CreateGSInt64Node, CreateGSIntegerNode, CreateGSIntSwissKnifeNode, CreateGSStringNode