Impact Acquire SDK C++
Component Class Reference

A base class to implement access to internal driver components. More...

#include <mvIMPACT_acquire.h>

Inheritance diagram for Component:
[legend]

Public Member Functions

unsigned int changedCounter (void) const
 Returns the current changed counter for the component referenced by this object.
 
unsigned int changedCounterAttr (void) const
 Returns the current attribute changed counter for the component referenced by this object.
 
 Component (const Component &src)
 Constructs a new mvIMPACT::acquire::Component from an existing one.
 
 Component (HOBJ hObj)
 Constructs a new access object to a driver object.
 
 Component (void)
 Constructs a new unbound access object.
 
std::string displayName (void) const
 Returns the display name of the component referenced by this object.
 
std::string docString (void) const
 Returns a string containing general information about the component referenced by this object.
 
Component firstChild (void) const
 Moves to the first child of this component(moves down one level).
 
Component firstSibling (void) const
 Moves to the first sibling(the first feature in the current list of features).
 
TComponentFlag flags (void) const
 Returns the flags associated with this component.
 
std::string flagsAsString (const std::string &separator=" | ") const
 Returns the flags associated with this component as a string.
 
HOBJ hObj (void) const
 Returns a unique identifier for the component referenced by this object.
 
bool isDefault (void) const
 Checks if this component is currently referencing the default for this component.
 
bool isList (void) const
 Checks if this component is of type mvIMPACT::acquire::ComponentList.
 
bool isMeth (void) const
 Checks if this component is of type mvIMPACT::acquire::Method.
 
bool isProp (void) const
 Checks if this component is of type mvIMPACT::acquire::Property or a derived type.
 
bool isValid (void) const
 Checks if the internal component referenced by this object is still valid.
 
bool isVisible (void) const
 Checks if the component is currently shadowed due to a settings made elsewhere or not.
 
bool isWriteable (void) const
 Checks if the caller has write/modify access to the component.
 
Component lastSibling (void) const
 Moves to the last sibling(the last feature in the current list of features).
 
std::string name (void) const
 Returns the name of the component referenced by this object.
 
Component nextSibling (void)
 Moves to the next sibling(the next feature in the current list of features).
 
 operator HOBJ () const
 Allows implicit conversion to a HOBJ.
 
Component operator++ (int)
 Moves to the next sibling(the next feature in the current list of features).
 
Componentoperator++ (void)
 Moves to the next sibling(the next feature in the current list of features).
 
Componentoperator= (const Component &rhs)
 Allows assignments of mvIMPACT::acquire::Component objects.
 
Component parent (void) const
 Moves to the parent of this component(moves up one level).
 
TComponentRepresentation representation (void) const
 Returns the recommended representation for this component.
 
std::string representationAsString (void) const
 Returns the recommended representation of the referenced component as a string.
 
const ComponentrestoreDefault (void) const
 Restores the default for the referenced component.
 
Component selectedFeature (unsigned int index) const
 Retrieves a component that is selected by the current one.
 
unsigned int selectedFeatureCount (void) const
 Returns the number of features selected by the current one.
 
unsigned int selectedFeatures (std::vector< Component > &v) const
 Retrieves the list of components that are selected by the current one.
 
Component selectingFeature (unsigned int index) const
 Retrieves a component that is selecting the current one.
 
unsigned int selectingFeatureCount (void) const
 Returns the number of features selecting the current one.
 
unsigned int selectingFeatures (std::vector< Component > &v) const
 Retrieves the list of components that are selecting the current one.
 
TComponentType type (void) const
 Returns the type of the referenced component.
 
std::string typeAsString (void) const
 Returns the type of the referenced component as a string.
 
TComponentVisibility visibility (void) const
 Returns the recommended visibility for this component.
 
std::string visibilityAsString (void) const
 Returns the recommended visibility of the referenced component as a string.
 

Static Public Member Functions

static std::string representationAsString (TComponentRepresentation representation)
 Returns the recommended representation converted to a string.
 
static TComponentType type (HOBJ hObj)
 Returns the type of the component referenced by hObj.
 
static std::string visibilityAsString (TComponentVisibility visibility)
 Returns the recommended visibility converted to a string.
 

Protected Types

enum  { BUFFER_INCREMENT_FACTOR = 6 }
 An internal constant that defines by which factor dynamic buffers will grow when the current size is not sufficient. More...
 

Protected Member Functions

std::string compGetStringParam (TOBJ_StringQuery query, int param1=0, int param2=0) const
 A helper function to query certain component related string parameters.
 

Static Protected Member Functions

static char * stringAllocator (const char *pBuf, size_t reqBufSize)
 An internal helper function for fast string allocation.
 

Protected Attributes

HOBJ m_hObj
 A unique identifier for the internal driver object referenced by this instance of mvIMPACT::acquire::ComponentAccess.
 

Detailed Description

A base class to implement access to internal driver components.

Objects of this class can be constructed directly even if nothing is known about the type of driver object we are referring to. This class acts as a base class to provide access to internal properties, methods and component lists offered by the driver.

This object can be used to navigate through component lists of unknown content.

Consider the following structure:

LA
|-LB
|-LC
| |-PE
| |-PF
| |-PG
|-PD

Where the prefix 'L' means this is a list, 'P' that this is a property. Assuming that we have and iterator referencing list 'C', calling mvIMPACT::acquire::Component::firstChild e.g. would return a new iterator referencing object 'PE', while calling mvIMPACT::acquire::Component::nextSibling would have returned a reference to 'PD' and mvIMPACT::acquire::Component::parent would have returned a reference to object 'LA'.

"EXAMPLE 1":

A new mvIMPACT::acquire::Component is created with the ID of list 'C':

Component it(ID_of_list_C);
it = it.firstChild(); // now we are referencing 'PE'
it = it.lastSibling(); // moves to 'PG'
it = it.firstSibling(); // moves back to PE'
it = it.nextSibling(); // moves to 'PF'
it = it.firstSibling(); // moves back to PE'
it = it.parent(); // we are referencing 'LC' again
A base class to implement access to internal driver components.
Definition mvIMPACT_acquire.h:1439

"EXAMPLE 2":

Iterate over a complete list including sub lists. This will result in a list of all lists and properties that reside in the list the iterator currently is moving through to be written to the standard output. The name of the component and every parent component will be printed into the standard output:

//-----------------------------------------------------------------------------
void ParseList( Component iter, const string& path = "" )
//-----------------------------------------------------------------------------
{
while( iter.isValid() )
{
if( iter.isVisible() )
{
if( iter.isList() )
{
// do some list specific stuff
cout << "List " << path << iter.name() << "/" << endl;
// move down into the list and append its name to the path
ParseList( iter.firstChild(), path + iter.name() + "/" );
}
else if( iter.isProp() )
{
// do property specific stuff e.g. read the value
Property prop( iter );
cout << "Property " << path << prop.name() << "(value(s): ";
unsigned int valCount = prop.valCount();
for( unsigned int i=0; i<valCount; i++ )
{
cout << prop.readS();
if( i < valCount - 1 )
{
cout << ", ";
}
}
cout << ")" << endl;
}
}
++iter;
}
}
//-----------------------------------------------------------------------------
int main( int argc, char* argv[] )
//-----------------------------------------------------------------------------
{
ComponentList baselist;
// ....
Component it( baselist );
ParseList( it );
// ....
return 0;
}
std::string name(void) const
Returns the name of the component referenced by this object.
Definition mvIMPACT_acquire.h:1206
bool isValid(void) const
Checks if the internal component referenced by this object is still valid.
Definition mvIMPACT_acquire.h:1721
Component(void)
Constructs a new unbound access object.
Definition mvIMPACT_acquire.h:1513
bool isProp(void) const
Checks if this component is of type mvIMPACT::acquire::Property or a derived type.
Definition mvIMPACT_acquire.h:1706
bool isList(void) const
Checks if this component is of type mvIMPACT::acquire::ComponentList.
Definition mvIMPACT_acquire.h:1686
Component firstChild(void) const
Moves to the first child of this component(moves down one level).
Definition mvIMPACT_acquire.h:1595
bool isVisible(void) const
Checks if the component is currently shadowed due to a settings made elsewhere or not.
Definition mvIMPACT_acquire.h:1745
A base class for properties.
Definition mvIMPACT_acquire.h:3134
Examples
Callback.cpp, ContinuousCapture.cpp, GenICamCallbackOnEvent.cpp, GenericInterfaceLayout.cpp, GenericInterfaceLayout.legacy.cpp, Properties.cpp, and Properties.legacy.cpp.

Member Enumeration Documentation

◆ anonymous enum

anonymous enum
protectedinherited

An internal constant that defines by which factor dynamic buffers will grow when the current size is not sufficient.

Enumerator
BUFFER_INCREMENT_FACTOR 

Constructor & Destructor Documentation

◆ Component() [1/3]

Component ( HOBJ hObj)
inlineexplicit

Constructs a new access object to a driver object.

Parameters
[in]hObjA valid handle to a component object

◆ Component() [2/3]

Component ( void )
inlineexplicit

Constructs a new unbound access object.

◆ Component() [3/3]

Component ( const Component & src)
inline

Constructs a new mvIMPACT::acquire::Component from an existing one.

Parameters
[in]srcA constant reference to the mvIMPACT::acquire::Component object, this object shall be created from

Member Function Documentation

◆ changedCounter()

unsigned int changedCounter ( void ) const
inlineinherited

Returns the current changed counter for the component referenced by this object.

This changed counter is incremented internally each time the component is modified. To check if this component has been modified since the last time, this check has been performed, keep track of the last return value of this function and compare it with the new value. This can be helpful e.g. to keep a GUI up to date. The value returned by this function will always be larger than or equal to the value returned by mvIMPACT::acquire::ComponentAccess::changedCounterAttr (except in case of a wrap around) when called at the same time for the same object as it's always incremented when the component has been modified in any way while the latter one will only be incremented if the attributes (e.g. the flags) but NOT if e.g. the value(s) of a property has been modified.

//-----------------------------------------------------------------------------
struct ComponentRef
//-----------------------------------------------------------------------------
{
unsigned int lastChangedCount_;
ComponentRef( mvIMPACT::acquire::Component c ) : c_( c ), lastChangedCount_( 0 ) {}
};
//-----------------------------------------------------------------------------
void fn( ComponentRef& cr )
//-----------------------------------------------------------------------------
{
if( cr.c_.isValid() )
{
const unsigned int currentChangedCount = cr.c_.changedCounter();
if( currentChangedCount != cr.lastChangedCount_ )
{
// something has happened since the last check!
doWhatNeedsToBeDone();
// and remember the current changed counter
cr.lastChangedCount_ = currentChangedCount;
}
}
}
Returns
The current changed counter of this object.

◆ changedCounterAttr()

unsigned int changedCounterAttr ( void ) const
inlineinherited

Returns the current attribute changed counter for the component referenced by this object.

This changed counter is incremented internally each time the components attributes have been modified. To check if this components attributes have been modified since the last time, this check has been performed, keep track of the last return value of this function and compare it with the new value. This can be helpful e.g. to keep a GUI up to date.

Note
Attributes changes are e.g. a modification to a property's translation dictionary, but NOT a property's value. Because of this the value returned by this function will always be less or equal than the value returned by the function mvIMPACT::acquire::ComponentAccess::changedCounter (except in case of a wrap around) when called at the same time for the same object.
See also
mvIMPACT::acquire::ComponentAccess::changedCounter
Returns
The current attributes changed counter of this object.

◆ compGetStringParam()

std::string compGetStringParam ( TOBJ_StringQuery query,
int param1 = 0,
int param2 = 0 ) const
inlineprotectedinherited

A helper function to query certain component related string parameters.

This function might throw an exception, if an invalid parameter has been queried.

Returns
A string containing the data to be queried.
Parameters
queryThe type of the parameter to read
[in]param1An additional parameter
[in]param2An additional parameter

◆ displayName()

std::string displayName ( void ) const
inlineinherited

Returns the display name of the component referenced by this object.

Since
1.11.20
Returns
The display name of the component referenced by this object. This might be an empty string if no display name has been specified.
Examples
GenICamSequencerParameterChangeAtRuntime.cpp, GenICamSequencerUsage.cpp, GenICamSequencerUsage.legacy.cpp, GenICamSequencerUsageWithPaths.cpp, GenICamSequencerUsageWithPaths.legacy.cpp, and exampleHelper.h.

◆ docString()

std::string docString ( void ) const
inline

Returns a string containing general information about the component referenced by this object.

Returns
A string containing general information about the component referenced by this object.
Examples
exampleHelper.h.

◆ firstChild()

Component firstChild ( void ) const
inline

Moves to the first child of this component(moves down one level).

Calling this function will only succeed, if the current mvIMPACT::acquire::Component references a list.

Returns
A new mvIMPACT::acquire::Component object
Examples
GenericInterfaceLayout.cpp, GenericInterfaceLayout.legacy.cpp, Properties.cpp, and Properties.legacy.cpp.

◆ firstSibling()

Component firstSibling ( void ) const
inline

Moves to the first sibling(the first feature in the current list of features).

Returns
A new mvIMPACT::acquire::Component object

◆ flags()

TComponentFlag flags ( void ) const
inline

Returns the flags associated with this component.

Returns
The flags associated with this component.

◆ flagsAsString()

std::string flagsAsString ( const std::string & separator = " | ") const
inline

Returns the flags associated with this component as a string.

Returns
The flags associated with this component as a string.
Parameters
[in]separatorA user definable string to separate the individual flags. The default value is ' | ' resulting in the string to look e.g. like this: 'cfWriteAccess | cfReadAccess'
Examples
exampleHelper.h.

◆ hObj()

HOBJ hObj ( void ) const
inlineinherited

Returns a unique identifier for the component referenced by this object.

Returns
A unique identifier for the component referenced by this object.

◆ isDefault()

bool isDefault ( void ) const
inline

Checks if this component is currently referencing the default for this component.

This function will return true only for derived components that have not been modified.

Returns
  • true if the component is currently set to its default value
  • false otherwise.

◆ isList()

bool isList ( void ) const
inline

Checks if this component is of type mvIMPACT::acquire::ComponentList.

Returns
  • true if the component references a list
  • false otherwise
Examples
GenericInterfaceLayout.cpp, GenericInterfaceLayout.legacy.cpp, Properties.cpp, and Properties.legacy.cpp.

◆ isMeth()

bool isMeth ( void ) const
inline

Checks if this component is of type mvIMPACT::acquire::Method.

Returns
  • true if the component references a method
  • false otherwise

◆ isProp()

bool isProp ( void ) const
inline

Checks if this component is of type mvIMPACT::acquire::Property or a derived type.

Returns
  • true if the component references a property
  • false otherwise
Examples
ContinuousCapture.cpp, GenICamCallbackOnEvent.cpp, GenericInterfaceLayout.cpp, GenericInterfaceLayout.legacy.cpp, Properties.cpp, and Properties.legacy.cpp.

◆ isValid()

bool isValid ( void ) const
inline

Checks if the internal component referenced by this object is still valid.

This function can be used to verify whether a referenced component is still valid or not. When e.g. referencing a driver property after mvIMPACT::acquire::Device::close has been called this function would return false. Calling any other function that tries to access the referenced component in that case would raise an exception.

Returns
  • true if this object currently references a valid component
  • false otherwise.
Examples
ContinuousCapture.cpp, ContinuousCapture.linux.cpp, ContinuousCaptureFFmpeg.cpp, ContinuousCaptureGenDC.cpp, DigitalIOs.cpp, DigitalIOs.legacy.cpp, GenICamCommonSettingsUsage.cpp, GenICamCommonSettingsUsage.legacy.cpp, GenICamI2cUsage.cpp, GenICamInterfaceLayout.cpp, GenICamInterfaceLayout.legacy.cpp, GenICamSequencerParameterChangeAtRuntime.cpp, GenICamSequencerUsage.cpp, GenICamSequencerUsage.legacy.cpp, GenICamSequencerUsageWithPaths.cpp, GenICamSequencerUsageWithPaths.legacy.cpp, GenICamSmartFrameRecallUsage.cpp, GenICamSmartFrameRecallUsage.legacy.cpp, GenericInterfaceLayout.cpp, GenericInterfaceLayout.legacy.cpp, GigEVisionActionFeatures.cpp, Properties.cpp, Properties.legacy.cpp, TimestampFeatures.cpp, and exampleHelper.h.

◆ isVisible()

bool isVisible ( void ) const
inline

Checks if the component is currently shadowed due to a settings made elsewhere or not.

Settings applied to certain components might affect the behaviour of others. For example an activated automatic gain control might shadow the value written to the gain property by the user as the gain is calculated internally. In order to check if modifying the actual component will affect the behaviour of the system this function may be used. When it returns true, the mvIMPACT::acquire::Component will have an impact on the system, if false is returned, the feature might be modified, but this will currently NOT influence the acquisition process or the overall behaviour of the device or driver.

This is what is called visibility. The user still might modify or read the current mvIMPACT::acquire::Component when it's not visible however the actual data will be used only if the Component is visible (mvIMPACT::acquire::cfInvisible must NOT be set).

The visibility of a mvIMPACT::acquire::Component object will change only if other mvIMPACT::acquire::Component objects are modified and NEVER when a program runs but does not change any mvIMPACT::acquire::Component.

Examples
ContinuousCapture.cpp.

◆ isWriteable()

bool isWriteable ( void ) const
inline

Checks if the caller has write/modify access to the component.

Returns
  • true if the caller is allowed to call write/modify operation for this component.
  • false otherwise.
Examples
exampleHelper.h.

◆ lastSibling()

Component lastSibling ( void ) const
inline

Moves to the last sibling(the last feature in the current list of features).

Since
1.10.64
Returns
A new mvIMPACT::acquire::Component object

◆ name()

◆ nextSibling()

Component nextSibling ( void )
inline

Moves to the next sibling(the next feature in the current list of features).

Returns
A new mvIMPACT::acquire::Component object

◆ operator HOBJ()

operator HOBJ ( ) const
inlineinherited

Allows implicit conversion to a HOBJ.

◆ operator++() [1/2]

Component operator++ ( int )
inline

Moves to the next sibling(the next feature in the current list of features).

Returns
A new mvIMPACT::acquire::Component object

◆ operator++() [2/2]

Component & operator++ ( void )
inline

Moves to the next sibling(the next feature in the current list of features).

Returns
A self reference

◆ operator=()

Component & operator= ( const Component & rhs)
inline

Allows assignments of mvIMPACT::acquire::Component objects.

◆ parent()

Component parent ( void ) const
inline

Moves to the parent of this component(moves up one level).

Returns
A new mvIMPACT::acquire::Component object

◆ representation()

TComponentRepresentation representation ( void ) const
inline

Returns the recommended representation for this component.

The representation can be used e.g. to develop a GUI that creates convenient controls for certain features.

Valid values for this property are defined by the enumeration mvIMPACT::acquire::TComponentRepresentation.

Since
2.14.0
Returns
The recommended representation for this component.

◆ representationAsString() [1/2]

static std::string representationAsString ( TComponentRepresentation representation)
inlinestatic

Returns the recommended representation converted to a string.

Since
2.14.0
Returns
The recommended representation converted to a string.
Parameters
[in]representationThe representation to query the string representation for

◆ representationAsString() [2/2]

std::string representationAsString ( void ) const
inline

Returns the recommended representation of the referenced component as a string.

Since
2.14.0
Returns
The recommended representation of the referenced component as a string.

◆ restoreDefault()

const Component & restoreDefault ( void ) const
inline

Restores the default for the referenced component.

Calling this function will restore the default value for the component referenced by this object.

If this function is called for an object of type mvIMPACT::acquire::ComponentList every component in that list is restored to the default value.

Note
The caller must have the right to modify the component. Otherwise an exception will be thrown.
Returns
A const reference to the component.

◆ selectedFeature()

Component selectedFeature ( unsigned int index) const
inline

Retrieves a component that is selected by the current one.

This function retrieves a component that is selected by the current one. This information is mainly useful for GUI applications that want to arrange features in a way that dependencies between features can easily been spotted.

When a component 'selects' other components, this indicates that selected components may change whenever the selecting component changes. An example for a selector might be a property defining the index within a LUT while the value of a particular LUT entry could be a selected feature. Assuming 2 properties LUTIndex and LUTValue then changing LUTIndex will invalidate and possibly change LUTValue.

C++ offers the more efficient function mvIMPACT::acquire::Component::selectedFeatures to obtain this information.

To find out how many mvIMPACT::acquire::Component objects are selected by the current one call mvIMPACT::acquire::Component::selectedFeatureCount. This value minus 1 will also be the max. value for index.

See also
mvIMPACT::acquire::Component::selectedFeatureCount,
mvIMPACT::acquire::Component::selectedFeatures
Since
1.11.20
Returns
A mvIMPACT::acquire::Component that is selected by the current one.
Parameters
[in]indexThe index for the component to query.

◆ selectedFeatureCount()

unsigned int selectedFeatureCount ( void ) const
inline

Returns the number of features selected by the current one.

See also
mvIMPACT::acquire::Component::selectedFeatures,
mvIMPACT::acquire::Component::selectedFeature
Since
1.11.20
Returns
The number of features selected by the current one.
Examples
exampleHelper.h.

◆ selectedFeatures()

unsigned int selectedFeatures ( std::vector< Component > & v) const
inline

Retrieves the list of components that are selected by the current one.

This function retrieves the list of components that are selected by the current one. This information is mainly useful for GUI applications that want to arrange features in a way that dependencies between features can easily been spotted.

When a component 'selects' other components, this indicates that selected components may change whenever the selecting component changes. An example for a selector might be a property defining the index within a LUT while the value of a particular LUT entry could be a selected feature. Assuming 2 properties LUTIndex and LUTValue then changing LUTIndex will invalidate and possibly change LUTValue.

See also
mvIMPACT::acquire::Component::selectedFeatureCount,
mvIMPACT::acquire::Component::selectedFeature
Since
1.11.20
Returns
The number of features selected by the current one.
Parameters
[out]vAn array that will retrieve the list of components that are selected by the current one.
Examples
exampleHelper.h.

◆ selectingFeature()

Component selectingFeature ( unsigned int index) const
inline

Retrieves a component that is selecting the current one.

This function retrieves a component that is selecting the current one. This information is mainly useful for GUI applications that want to arrange features in a way that dependencies between features can easily been spotted.

When a component 'selects' other components, this indicates that selected components may change whenever the selecting component changes. An example for a selector might be a property defining the index within a LUT while the value of a particular LUT entry could be a selected feature. Assuming 2 properties LUTIndex and LUTValue then changing LUTIndex will invalidate and possibly change LUTValue.

C++ offers the more efficient function mvIMPACT::acquire::Component::selectingFeatures to obtain this information.

To find out how many mvIMPACT::acquire::Component objects are selecting the current one call mvIMPACT::acquire::Component::selectingFeatureCount. This value minus 1 will also be the max. value for index.

See also
mvIMPACT::acquire::Component::selectingFeatureCount,
mvIMPACT::acquire::Component::selectingFeatures
Since
1.11.20
Returns
A mvIMPACT::acquire::Component that is selecting the current one.
Parameters
[in]indexThe index for the component to query.

◆ selectingFeatureCount()

unsigned int selectingFeatureCount ( void ) const
inline

Returns the number of features selecting the current one.

See also
mvIMPACT::acquire::Component::selectingFeatures,
mvIMPACT::acquire::Component::selectingFeature
Since
1.11.20
Returns
The number of features selecting the current one.
Examples
exampleHelper.h.

◆ selectingFeatures()

unsigned int selectingFeatures ( std::vector< Component > & v) const
inline

Retrieves the list of components that are selecting the current one.

This function retrieves the list of components that are selecting the current one. This information is mainly useful for GUI applications that want to arrange features in a way that dependencies between features can easily been spotted.

When a component 'selects' other components, this indicates that selected components may change whenever the selecting component changes. An example for a selector might be a property defining the index within a LUT while the value of a particular LUT entry could be a selected feature. Assuming 2 properties LUTIndex and LUTValue then changing LUTIndex will invalidate and possibly change LUTValue.

See also
mvIMPACT::acquire::Component::selectingFeatureCount,
mvIMPACT::acquire::Component::selectingFeature
Since
1.11.20
Returns
The number of features selecting the current one.
Parameters
[out]vAn array that will retrieve the list of components that are selecting the current one.
Examples
exampleHelper.h.

◆ stringAllocator()

static char * stringAllocator ( const char * pBuf,
size_t reqBufSize )
inlinestaticprotectedinherited

An internal helper function for fast string allocation.

◆ type() [1/2]

static TComponentType type ( HOBJ hObj)
inlinestatic

Returns the type of the component referenced by hObj.

Returns
The type of the component referenced by hObj.
Parameters
[in]hObjThe component the type shall be retrieved for

◆ type() [2/2]

TComponentType type ( void ) const
inline

Returns the type of the referenced component.

Returns
The type of the referenced component.
Examples
exampleHelper.h.

◆ typeAsString()

std::string typeAsString ( void ) const
inline

Returns the type of the referenced component as a string.

Returns
The type of the referenced component as a string.
Examples
exampleHelper.h.

◆ visibility()

TComponentVisibility visibility ( void ) const
inline

Returns the recommended visibility for this component.

The visibility can be used e.g. to develop a GUI that displays a crucial subset of features only.

Valid values for this property are defined by the enumeration mvIMPACT::acquire::TComponentVisibility.

Returns
The recommended visibility for this component.

◆ visibilityAsString() [1/2]

static std::string visibilityAsString ( TComponentVisibility visibility)
inlinestatic

Returns the recommended visibility converted to a string.

Returns
The recommended visibility converted to a string.
Parameters
[in]visibilityThe visibility to query the string representation for

◆ visibilityAsString() [2/2]

std::string visibilityAsString ( void ) const
inline

Returns the recommended visibility of the referenced component as a string.

Returns
The recommended visibility of the referenced component as a string.

Member Data Documentation

◆ m_hObj

HOBJ m_hObj
protectedinherited

A unique identifier for the internal driver object referenced by this instance of mvIMPACT::acquire::ComponentAccess.