CPPCli::VXSystem Class Reference

The VXSystem class represents a VideoXpert system. It is the entry point of the VideoXpert SDK and allows the user to manage the system and devices. More...

#include <VXSystem.h>

Public Types
enum	SearchStatus {   SearchStatus::Unknown,   SearchStatus::InProgress,   SearchStatus::Complete }
	Values that represent the current status of an AutoAddDevices search. More...

Public Member Functions
delegate void	EventCallbackDelegate (VxSdk::IVxEvent *vxEvent)
	The native event callback delegate. More...
delegate void	InternalEventCallbackDelegate (VxSdk::VxInternalEvent *vxInternalEvent)
	The native internal event callback delegate. More...
delegate void	EventDelegate (Event^ vxEvent)
	The managed event delegate. More...
delegate void	InternalEventDelegate (InternalEvent^ sdkEvent)
	The managed internal event delegate. More...
	VXSystem (System::String^ ip)
	Constructor that takes an IP as a parameter. More...
	VXSystem (System::String^ ip, int port, bool useSSL)
	Constructor that takes an IP as a parameter. More...
virtual	~VXSystem ()
	Virtual destructor. More...
	!VXSystem ()
	Finaliser. More...
Results::Value	AddDataObject (NewDataObject^ newDataObject)
	Create a new data object on the VideoXpert system. More...
Results::Value	AddDevice (NewDevice^ newDevice)
	Add a device to the VideoXpert system. More...
Results::Value	AddDrawing (System::String^ drawingName)
	Create a new drawing on the VideoXpert system. More...
ManualRecording^	AddManualRecording (NewManualRecording^ newManualRecording)
	Add a new manual recording to the VideoXpert system. More...
Results::Value	AddRole (System::String^ roleName)
	Create a new role on the VideoXpert system. More...
Results::Value	AddSchedule (NewSchedule^ newSchedule)
	Add a new schedule on the VideoXpert system. More...
Results::Value	AddSituation (NewSituation^ newSituation)
	Add a new situation to the system. More...
Results::Value	AddUser (NewUser^ newUser)
	Create a new user on the VideoXpert system. More...
Results::Value	AutoAddDevices ()
	Initiates a network search on the VideoXpert system which automatically adds any new Pelco devices discovered. More...
Results::Value	CommissionDevice (Device^ device)
	Commissions a device for use within the VideoXpert system. More...
Results::Value	CreateBookmark (NewBookmark^ newBookmark)
	Create a new bookmark on the VideoXpert system. More...
Export^	CreateExport (NewExport^ newExport)
	Create a new export on the VideoXpert system. More...
Results::Value	CreateMonitor (NewMonitor^ newMonitor)
	Create a new monitor on the VideoXpert system. More...
Notification^	CreateNotification (NewNotification^ newNotification)
	Create a new notification on the VideoXpert system. More...
QuickLog^	CreateQuickLog ()
	Create a new quick log on the VideoXpert system. More...
QuickReport^	CreateQuickReport (NewQuickReport^ newQuickReport)
	Create a new quick report on the VideoXpert system. More...
Results::Value	CreateTag (NewTag^ newTag)
	Create a new tag on the VideoXpert system. More...
Results::Value	DecommissionDevice (Device^ device)
	Decommissions a device on the VideoXpert system. More...
Results::Value	DeleteBookmark (Bookmark^ bookmarkItem)
	Delete a bookmark from the VideoXpert system. More...
Results::Value	DeleteDataObject (DataObject^ dataObject)
	Delete a data object from the VideoXpert system. More...
Results::Value	DeleteDevice (Device^ device)
	Delete a device and its hosted data sources and data storages from the VideoXpert system. If the device is assigned to a datastorage, it shall be unassigned. More...
Results::Value	DeleteDrawing (Drawing^ drawingItem)
	Delete a drawing from the VideoXpert system. More...
Results::Value	DeleteExport (Export^ exportItem)
	Delete an export from the VideoXpert system. More...
Results::Value	DeleteManualRecording (ManualRecording^ manualRecordingItem)
	Delete a manual recording from the VideoXpert system. More...
Results::Value	DeleteNotification (Notification^ notificationItem)
	Delete a notification from the VideoXpert system. More...
Results::Value	DeleteRole (Role^ role)
	Delete a role from the VideoXpert system. More...
Results::Value	DeleteSchedule (Schedule^ scheduleItem)
	Delete a schedule from the VideoXpert system. More...
Results::Value	DeleteSituation (Situation^ situationItem)
	Delete an existing situation from the system. More...
Results::Value	DeleteTag (Tag^ tagItem)
	Delete a tag from the VideoXpert system. More...
Results::Value	DeleteUser (User^ user)
	Delete a user from the VideoXpert system. More...
System::Collections::Generic::List< AlarmInput^ >^	GetAlarmInputs ()
	Get the alarm inputs from the VideoXpert system. More...
System::Collections::Generic::List< Bookmark^ >^	GetBookmarks ()
	Get the bookmarks from the VideoXpert system. More...
System::Collections::Generic::List< DataObject^ >^	GetDataObjects ()
	Get the data objects from the VideoXpert system. More...
System::Collections::Generic::List< DataSource^ >^	GetDataSources ()
	Get the data sources from the VideoXpert system. More...
System::Collections::Generic::List< DataStorage^ >^	GetDataStorages ()
	Get the data storages residing on the system. More...
System::Collections::Generic::List< DeviceAssignment^ >^	GetDeviceAssignments ()
	Get the device assignments residing on the system. More...
System::Collections::Generic::List< Device^ >^	GetDevices ()
	Get the devices from the VideoXpert system. More...
System::Collections::Generic::List< Drawing^ >^	GetDrawings ()
	Get the drawings from the VideoXpert system. More...
System::Collections::Generic::List< Export^ >^	GetExports ()
	Get the exports residing on the system. More...
License^	GetLicense ()
	Get the license from the system. More...
System::Collections::Generic::List< ManualRecording^ >^	GetManualRecordings ()
	Gets the manual recordings residing on the system. More...
System::Collections::Generic::List< Monitor^ >^	GetMonitors ()
	Get the monitors residing on the system. More...
System::Collections::Generic::List< Notification^ >^	GetNotifications ()
	Get the notifications from the VideoXpert system. More...
System::Collections::Generic::List< RelayOutput^ >^	GetRelayOutputs ()
	Get the relay outputs from the VideoXpert system. More...
System::Collections::Generic::List< Role^ >^	GetRoles ()
	Get the roles from the VideoXpert system. More...
System::Collections::Generic::List< Schedule^ >^	GetSchedules ()
	Get the schedules from the VideoXpert system. More...
System::Collections::Generic::List< Situation^ >^	GetSituations ()
	Get the situations residing on the system. More...
System::Collections::Generic::List< Tag^ >^	GetTags ()
	Get the tags from the VideoXpert system. More...
System::Collections::Generic::List< User^ >^	GetUsers ()
	Get the users from the VideoXpert system. More...
Results::Value	InjectEvent (NewEvent^ newEvent)
	Insert a new event into the system. More...
Results::Value	Login (System::String^ username, System::String^ password)
	Log in to the VideoXpert system. More...
Results::Value	Login (System::String^ authToken)
	Log in to the VideoXpert system. More...
Results::Value	Refresh ()
	Update this instances properties. More...
Results::Value	RemoveMonitor (Monitor^ monitorItem)
	Delete a monitor from the VideoXpert system. More...
System::Collections::Generic::List< Event^ >^	SearchEvents (System::String^ type, System::DateTime^ start, System::DateTime^ end, int index, int count)
	Search for events on the system. More...
Results::Value	SubscribeToEventsByType (EventDelegate^ eventDelegate, System::Collections::Generic::List< Situation^ >^situations)
	Subscribe to system events by situation type, regardless of its notification setting. More...

Package Functions
Configuration::Cluster^	_GetClusterConfig ()
CPPCli::User^	_GetCurrentUser ()
CPPCli::Device^	_GetHostDevice ()

Static Package Functions
static void	_FireEvent (VxSdk::IVxEvent *vxEvent)
static void	_FireInternalEvent (VxSdk::VxInternalEvent *vxInternalEvent)

Package Attributes
VxSdk::IVxSystem *	_system
EventCallbackDelegate^	_callback
InternalEventCallbackDelegate^	_internalCallback
VxSdk::VxLoginInfo *	_loginInfo

Static Package Attributes
static EventDelegate^	_systemEvent
static InternalEventDelegate^	_sdkEvent

Properties
Configuration::Cluster^	ClusterConfig [get]
	Gets the cluster configuration from the VideoXpert system. More...
User^	Currentuser [get]
	Gets the user currently accessing the VideoXpert system. More...
SearchStatus	DeviceSearchStatus [get]
	Gets the current SearchStatus of an AutoAddDevices search. More...
CPPCli::Device^	HostDevice [get]
	Gets the device that hosts this system. More...
System::String^	Id [get]
	Gets the unique identifier of the VideoXpert system. More...
System::String^	Name [get, set]
	Gets the friendly name of the VideoXpert system. More...

Events
EventDelegate^	SystemEvent [add, remove]
	SystemEvent is raised whenever a new event is created on the system. More...
InternalEventDelegate^	InternalEvent [add, remove]
	InternalEvent is raised whenever a new internal event is sent from the VxSDK. More...

Detailed Description

The VXSystem class represents a VideoXpert system. It is the entry point of the VideoXpert SDK and allows the user to manage the system and devices.

Definition at line 35 of file VXSystem.h.

Member Enumeration Documentation

enum CPPCli::VXSystem::SearchStatus

strong

Values that represent the current status of an AutoAddDevices search.

Enumerator
Unknown	An error or unknown value was returned.
InProgress	Device search is in progress.
Complete	Device search has completed.

Definition at line 41 of file VXSystem.h.

                                {
            Unknown,

            InProgress,

            Complete
        };

Constructor & Destructor Documentation

CPPCli::VXSystem::VXSystem

(

System::String^

ip

)

Constructor that takes an IP as a parameter.

Parameters

ip	The IP address of the VideoXpert system.

CPPCli::VXSystem::VXSystem	(	System::String^	ip,
		int	port,
		bool	useSSL
	)

Constructor that takes an IP as a parameter.

Parameters

ip	The IP address of the VideoXpert system.
port	The port used by the VideoXpert system.
useSSL	Whether or not to use SSL encryption

virtual CPPCli::VXSystem::~VXSystem ( )

inlinevirtual

Virtual destructor.

Definition at line 97 of file VXSystem.h.

                            {
            this->!VXSystem();
        }

CPPCli::VXSystem::!VXSystem

(

)

Finaliser.

Definition at line 24 of file VXSystem.cpp.

                          {
    // Delete system object
    if (_system != nullptr) {
        // Unsubscribe to the system events
        _system->StopNotifications();
        _system->StopInternalNotifications();
        delete _callback;
        _system->Delete();
        _system = nullptr;
    }

    // Delete loginInfo object
    if (_loginInfo != nullptr) {
        delete _loginInfo;
    }
}

Member Function Documentation

void CPPCli::VXSystem::_FireEvent ( VxSdk::IVxEvent *  vxEvent )

staticpackage

Definition at line 1106 of file VXSystem.cpp.

                                                      {
    // Fire the notification if there is a subscription to the system events
    if (_systemEvent != nullptr)
        return _systemEvent(gcnew Event(vxEvent));
}

void CPPCli::VXSystem::_FireInternalEvent ( VxSdk::VxInternalEvent *  vxInternalEvent )

staticpackage

Definition at line 1112 of file VXSystem.cpp.

                                                                             {
    // Fire the notification if there is a subscription to the internal events
    if (_sdkEvent != nullptr)
        return _sdkEvent(gcnew CPPCli::InternalEvent(vxInternalEvent));
}

CPPCli::Configuration::Cluster CPPCli::VXSystem::_GetClusterConfig ( )

package

Definition at line 1118 of file VXSystem.cpp.

                                                              {
    // Get the cluster configuration
    VxSdk::IVxConfiguration::Cluster* cluster = nullptr;
    VxSdk::VxResult::Value result = _system->GetClusterConfiguration(cluster);

    // Return the cluster configuration if GetClusterConfiguration was successful
    if (result == VxSdk::VxResult::kOK)
        return gcnew Configuration::Cluster(cluster);

    return nullptr;
}

CPPCli::User CPPCli::VXSystem::_GetCurrentUser ( )

package

Definition at line 1130 of file VXSystem.cpp.

                                            {
    // Get the user object
    VxSdk::IVxUser* user = nullptr;
    VxSdk::VxResult::Value result = _system->GetCurrentUser(user);

    // Return the user if GetCurrentUser was successful
    if (result == VxSdk::VxResult::kOK)
        return gcnew CPPCli::User(user);

    return nullptr;
}

CPPCli::Device CPPCli::VXSystem::_GetHostDevice ( )

package

Definition at line 1142 of file VXSystem.cpp.

                                             {
    // Get the device which hosts this system
    VxSdk::IVxDevice* device = nullptr;
    VxSdk::VxResult::Value result = _system->GetHostDevice(device);

    // Return the device if GetHostDevice was successful
    if (result == VxSdk::VxResult::kOK)
        return gcnew Device(device);

    return nullptr;
}

CPPCli::Results::Value CPPCli::VXSystem::AddDataObject

(

CPPCli::NewDataObject^

newDataObject

)

Create a new data object on the VideoXpert system.

Parameters

newDataObject

The new data object to be added to the system.

Returns

The Result of adding the data object.

Definition at line 41 of file VXSystem.cpp.

                                                                                   {
    // Create a new data object and populate its fields using newDataObject
    VxSdk::VxNewDataObject vxDataObject;
    VxSdk::Utilities::StrCopySafe(vxDataObject.clientType, Utils::ConvertSysString(newDataObject->ClientType));
    vxDataObject.data = Utils::ConvertSysStringNonConst(newDataObject->Data);
    vxDataObject.isPrivate = newDataObject->IsPrivate;

    // Make the call to add the data object into VideoXpert
    VxSdk::VxResult::Value result = _system->AddDataObject(vxDataObject);
    // Unless there was an issue creating the data object the result should be VxSdk::VxResult::kOK
    return CPPCli::Results::Value(result);
}

CPPCli::Results::Value CPPCli::VXSystem::AddDevice

(

CPPCli::NewDevice^

newDevice

)

Add a device to the VideoXpert system.

Parameters

newDevice

The new device to be added.

Returns

The Result of the request.

Definition at line 54 of file VXSystem.cpp.

                                                                       {
    VxSdk::VxNewDevice vxNewDevice;
    vxNewDevice.shouldAutoCommission = newDevice->ShouldAutoCommission;
    VxSdk::Utilities::StrCopySafe(vxNewDevice.dataStorageId, Utils::ConvertSysString(newDevice->DataStorageId));
    VxSdk::Utilities::StrCopySafe(vxNewDevice.driverType, Utils::ConvertSysString(newDevice->DriverType));
    VxSdk::Utilities::StrCopySafe(vxNewDevice.ip, Utils::ConvertSysString(newDevice->Ip));
    VxSdk::Utilities::StrCopySafe(vxNewDevice.name, Utils::ConvertSysString(newDevice->Name));
    VxSdk::Utilities::StrCopySafe(vxNewDevice.password, Utils::ConvertSysString(newDevice->Password));
    VxSdk::Utilities::StrCopySafe(vxNewDevice.username, Utils::ConvertSysString(newDevice->Username));
    vxNewDevice.type = VxSdk::VxDeviceType::Value(newDevice->Type);


    // Make the call to add the device into VideoXpert
    VxSdk::VxResult::Value result = _system->AddDevice(vxNewDevice);
    // Unless there was an issue creating the device the result should be VxSdk::VxResult::kOK
    return CPPCli::Results::Value(result);
}

CPPCli::Results::Value CPPCli::VXSystem::AddDrawing

(

System::String^

drawingName

)

Create a new drawing on the VideoXpert system.

Parameters

drawingName

The name of the new drawing to be added to the system.

Returns

The Result of adding the drawing.

Definition at line 72 of file VXSystem.cpp.

                                                                       {
    VxSdk::VxNewDrawing vxDrawing;
    VxSdk::Utilities::StrCopySafe(vxDrawing.name, Utils::ConvertSysString(drawingName));

    // Make the call to add the drawing into VideoXpert
    VxSdk::VxResult::Value result = _system->AddDrawing(vxDrawing);
    // Unless there was an issue creating the drawing the result should be VxSdk::VxResult::kOK
    return CPPCli::Results::Value(result);
}

CPPCli::ManualRecording CPPCli::VXSystem::AddManualRecording

(

CPPCli::NewManualRecording^

newManualRecording

)

Add a new manual recording to the VideoXpert system.

Parameters

newManualRecording

The new manual recording to be added.

Returns

nullptr if it fails, else the new manual recording.

Definition at line 82 of file VXSystem.cpp.

                                                                                                      {
    VxSdk::VxNewManualRecording vxNewManualRecording;
    VxSdk::Utilities::StrCopySafe(vxNewManualRecording.dataSourceId, Utils::ConvertSysString(newManualRecording->DataSourceId));
    vxNewManualRecording.postRecord = newManualRecording->PostRecord;
    vxNewManualRecording.preRecord = newManualRecording->PreRecord;

    CPPCli::ManualRecording^ retManualRecording = nullptr;
    // Make the call to add the manual recording into VideoXpert
    VxSdk::IVxManualRecording* manualRecordingItem = nullptr;
    VxSdk::VxResult::Value result = _system->AddManualRecording(vxNewManualRecording, manualRecordingItem);

    // Unless there was an issue adding the manual recording the result should be VxSdk::VxResult::kOK
    if (result == VxSdk::VxResult::kOK) {
        retManualRecording = gcnew CPPCli::ManualRecording(manualRecordingItem);
    }
    return retManualRecording;
}

CPPCli::Results::Value CPPCli::VXSystem::AddRole

(

System::String^

roleName

)

Create a new role on the VideoXpert system.

Parameters

roleName

The new role to be added to the system.

Returns

The Result of adding the role.

Definition at line 100 of file VXSystem.cpp.

                                                                 {
    // Make the call to add the role into VideoXpert
    VxSdk::VxResult::Value result = _system->AddRole(Utils::ConvertSysString(roleName));
    // Unless there was an issue creating the role the result should be VxSdk::VxResult::kOK
    return CPPCli::Results::Value(result);
}

CPPCli::Results::Value CPPCli::VXSystem::AddSchedule

(

CPPCli::NewSchedule^

newSchedule

)

Add a new schedule on the VideoXpert system.

Parameters

newSchedule

The new schedule to be added to the system.

Returns

The Result of adding the schedule.

Definition at line 107 of file VXSystem.cpp.

                                                                             {
    // Create a schedule object and populate its fields using newSchedule
    VxSdk::VxNewSchedule vxSchedule;
    VxSdk::Utilities::StrCopySafe(vxSchedule.id, Utils::ConvertSysString(newSchedule->Id));
    VxSdk::Utilities::StrCopySafe(vxSchedule.name, Utils::ConvertSysString(newSchedule->Name));
    vxSchedule.action = (VxSdk::VxScheduleAction::Value)newSchedule->Action;
    vxSchedule.useAllDataSources = newSchedule->UseAllDataSources;

    // Create new VxNewScheduleTrigger objects using the ScheduleTrigger info contained in newSchedule
    const int triggerSize = newSchedule->ScheduleTriggers->Count;
    VxSdk::VxNewScheduleTrigger* newTriggers = new VxSdk::VxNewScheduleTrigger[triggerSize];
    for (int i = 0; i < triggerSize; i++) {
        VxSdk::Utilities::StrCopySafe(newTriggers[i].dailyEndTime, Utils::ConvertDateTimeToTimeChar(newSchedule->ScheduleTriggers[i]->DailyEndTime));
        VxSdk::Utilities::StrCopySafe(newTriggers[i].dailyStartTime, Utils::ConvertDateTimeToTimeChar(newSchedule->ScheduleTriggers[i]->DailyStartTime));
        VxSdk::Utilities::StrCopySafe(newTriggers[i].endDate, Utils::ConvertDateTimeToChar(newSchedule->ScheduleTriggers[i]->EndDate));
        VxSdk::Utilities::StrCopySafe(newTriggers[i].startDate, Utils::ConvertDateTimeToChar(newSchedule->ScheduleTriggers[i]->StartDate));
        VxSdk::Utilities::StrCopySafe(newTriggers[i].id, Utils::ConvertSysString(newSchedule->ScheduleTriggers[i]->Id));
        VxSdk::Utilities::StrCopySafe(newTriggers[i].eventSourceDevice, Utils::ConvertSysString(newSchedule->ScheduleTriggers[i]->EventSource));
        newTriggers[i].postTrigger = newSchedule->ScheduleTriggers[i]->PostTrigger;
        newTriggers[i].preTrigger = newSchedule->ScheduleTriggers[i]->PreTrigger;
        newTriggers[i].timeout = newSchedule->ScheduleTriggers[i]->Timeout;
        newTriggers[i].event = VxSdk::VxSituationType::Value(newSchedule->ScheduleTriggers[i]->Event);
        newTriggers[i].recurrence = VxSdk::VxRecurrenceType::Value(newSchedule->ScheduleTriggers[i]->RecurrenceType);
        newTriggers[i].framerate = VxSdk::VxRecordingFramerate::Value(newSchedule->ScheduleTriggers[i]->Framerate);

        // Add any weekly interval values to the new schedule trigger
        int weeklySize = newSchedule->ScheduleTriggers[i]->RecurWeekly->Count;
        int *weekIntervals = new int[weeklySize];
        for (int iW = 0; iW < weeklySize; iW++) {
            weekIntervals[iW] = newSchedule->ScheduleTriggers[i]->RecurWeekly[iW];
        }
        newTriggers[i].recurWeekly = weekIntervals;
        newTriggers[i].recurWeeklySize = weeklySize;

        // Add any monthly interval values to the new schedule trigger
        int monthlySize = newSchedule->ScheduleTriggers[i]->RecurMonthly->Count;
        int *monthIntervals = new int[monthlySize];
        for (int iM = 0; iM < monthlySize; iM++) {
            monthIntervals[iM] = newSchedule->ScheduleTriggers[i]->RecurMonthly[iM];
        }
        newTriggers[i].recurMonthly = monthIntervals;
        newTriggers[i].recurMonthlySize = monthlySize;

        // Add any yearly interval values to the new schedule trigger
        int yearlySize = newSchedule->ScheduleTriggers[i]->RecurYearly->Count;
        int *yearIntervals = new int[yearlySize];
        for (int iY = 0; iY < yearlySize; iY++) {
            yearIntervals[iY] = newSchedule->ScheduleTriggers[i]->RecurYearly[iY];
        }
        newTriggers[i].recurYearly = yearIntervals;
        newTriggers[i].recurYearlySize = yearlySize;

        // Add any event properties to the new schedule trigger
        int size = newSchedule->ScheduleTriggers[i]->EventProperties->Count;
        VxSdk::VxKvObject *kvObj = new VxSdk::VxKvObject[size];
        newTriggers[i].eventPropertySize = size;
        newTriggers[i].eventProperties = kvObj;
        for (int ii = 0; ii < size; ii++) {
            VxSdk::Utilities::StrCopySafe(newTriggers[i].eventProperties[ii].key,
                Utils::ConvertSysString(newSchedule->ScheduleTriggers[i]->EventProperties[ii].Key));
            VxSdk::Utilities::StrCopySafe(newTriggers[i].eventProperties[ii].value,
                Utils::ConvertSysString(newSchedule->ScheduleTriggers[i]->EventProperties[ii].Value));
        }
    }
    // Add the schedule triggers to the new schedule
    vxSchedule.scheduleTriggers = newTriggers;
    vxSchedule.scheduleTriggerSize = triggerSize;

    // Make the call to add the schedule into VideoXpert
    VxSdk::VxResult::Value result = _system->AddSchedule(vxSchedule);
    // Unless there was an issue adding the schedule the result should be VxSdk::VxResult::kOK
    return CPPCli::Results::Value(result);
}

CPPCli::Results::Value CPPCli::VXSystem::AddSituation

(

CPPCli::NewSituation^

newSituation

)

Add a new situation to the system.

Parameters

newSituation

The new situation to be added to the system.

Returns

The Result of adding the situation.

Definition at line 181 of file VXSystem.cpp.

                                                                                {
    // Create a situation object and populate its fields using newSituation
    VxSdk::VxNewSituation vxSituation;
    VxSdk::Utilities::StrCopySafe(vxSituation.name, Utils::ConvertSysString(newSituation->Name));
    VxSdk::Utilities::StrCopySafe(vxSituation.sourceDeviceId, Utils::ConvertSysString(newSituation->SourceDeviceId));
    VxSdk::Utilities::StrCopySafe(vxSituation.type, Utils::ConvertSysString(newSituation->Type));
    vxSituation.isAckNeeded = newSituation->IsAckNeeded;
    vxSituation.audibleLoopDelay = newSituation->AudibleLoopDelay;
    vxSituation.shouldAudiblyNotify = newSituation->UseAudibleNotification;
    vxSituation.audiblePlayCount = newSituation->AudiblePlayCount;
    vxSituation.autoAcknowledge = newSituation->AutoAcknowledge;
    vxSituation.shouldExpandBanner = newSituation->ShouldExpandBanner;
    vxSituation.shouldLog = newSituation->ShouldLog;
    vxSituation.shouldNotify = newSituation->ShouldNotify;
    vxSituation.severity = newSituation->Severity;
    int size = newSituation->SnoozeIntervals->Count;
    int *intervals = new int[size];
    for (int i = 0; i < size; i++) {
        intervals[i] = newSituation->SnoozeIntervals[i];
    }
    vxSituation.snoozeIntervals = intervals;

    // Make the call to add the situation into VideoXpert
    VxSdk::VxResult::Value result = _system->AddSituation(vxSituation);
    // Unless there was an issue adding the situation the result should be VxSdk::VxResult::kOK
    if (result == VxSdk::VxResult::kOK) {
        // Remove the memory we previously allocated
        delete[] vxSituation.snoozeIntervals;
    }
    return CPPCli::Results::Value(result);
}

CPPCli::Results::Value CPPCli::VXSystem::AddUser

(

CPPCli::NewUser^

newUser

)

Create a new user on the VideoXpert system.

Parameters

newUser

The new user to be added to the system.

Returns

The Result of adding the user.

Definition at line 213 of file VXSystem.cpp.

                                                                 {
    // Create a new user object and populate its fields using newUser
    VxSdk::VxNewUser vxNewUser;
    VxSdk::Utilities::StrCopySafe(vxNewUser.domain, Utils::ConvertSysString(newUser->Domain));
    VxSdk::Utilities::StrCopySafe(vxNewUser.name, Utils::ConvertSysString(newUser->Name));
    VxSdk::Utilities::StrCopySafe(vxNewUser.password, Utils::ConvertSysString(newUser->Password));
    vxNewUser.mustChangePassword = newUser->MustChangePassword;

    // Make the call to add the user into VideoXpert
    VxSdk::VxResult::Value result = _system->AddUser(vxNewUser);
    // Unless there was an issue creating the user the result should be VxSdk::VxResult::kOK
    return CPPCli::Results::Value(result);
}

CPPCli::Results::Value CPPCli::VXSystem::AutoAddDevices

(

)

Initiates a network search on the VideoXpert system which automatically adds any new Pelco devices discovered.

Returns

The Result of the request.

Definition at line 227 of file VXSystem.cpp.

                                                  {
    // Make the call to AutoAddDevices
    VxSdk::VxResult::Value result = _system->AutoAddDevices();
    // Unless there was an issue starting the device discorvery the result should be VxSdk::VxResult::kOK
    return CPPCli::Results::Value(result);
}

CPPCli::Results::Value CPPCli::VXSystem::CommissionDevice

(

CPPCli::Device^

device

)

Commissions a device for use within the VideoXpert system.

Parameters

device

The device to commission.

Returns

The Result of commissioning the device.

Definition at line 234 of file VXSystem.cpp.

                                                                        {
    // Get the license object
    VxSdk::IVxLicense* license = nullptr;
    VxSdk::VxResult::Value result = _system->GetLicense(license);
    if (result != VxSdk::VxResult::kOK || license == nullptr)
        return (CPPCli::Results::Value)result;

    return (CPPCli::Results::Value)license->CommissionDevice(*device->_device);
}

CPPCli::Results::Value CPPCli::VXSystem::CreateBookmark

(

CPPCli::NewBookmark^

newBookmark

)

Create a new bookmark on the VideoXpert system.

Parameters

newBookmark

The new bookmark to be added to the system.

Returns

The Result of adding the bookmark.

Definition at line 244 of file VXSystem.cpp.

                                                                                {
    // Create a bookmark object and populate its fields using newBookmark
    VxSdk::VxNewBookmark vxBookmark;
    VxSdk::Utilities::StrCopySafe(vxBookmark.dataSourceId, Utils::ConvertSysString(newBookmark->DataSourceId));
    VxSdk::Utilities::StrCopySafe(vxBookmark.description, Utils::ConvertSysString(newBookmark->Description));
    VxSdk::Utilities::StrCopySafe(vxBookmark.name, Utils::ConvertSysString(newBookmark->Name));
    VxSdk::Utilities::StrCopySafe(vxBookmark.time, Utils::ConvertDateTimeToChar(newBookmark->Time));

    // Make the call to add the bookmark into VideoXpert
    VxSdk::VxResult::Value result = _system->AddBookmark(vxBookmark);
    // Unless there was an issue creating the bookmark the result should be VxSdk::VxResult::kOK
    return CPPCli::Results::Value(result);
}

CPPCli::Export CPPCli::VXSystem::CreateExport

(

CPPCli::NewExport^

newExport

)

Create a new export on the VideoXpert system.

Parameters

newExport

The new export to be added to the system.

Returns

nullptr if it fails, else the new export.

Definition at line 258 of file VXSystem.cpp.

                                                                     {
    // Create a new VxNewExportClip object using the clip info contained in newExport
    const int clipSize = newExport->Clips->Count;
    VxSdk::VxNewExportClip* clips = new VxSdk::VxNewExportClip[clipSize];
    for (int i = 0; i < clipSize; i++) {
        VxSdk::Utilities::StrCopySafe(clips[i].dataSourceId, Utils::ConvertSysString(newExport->Clips[i]->DataSourceId));
        VxSdk::Utilities::StrCopySafe(clips[i].startTime, Utils::ConvertDateTimeToChar(newExport->Clips[i]->StartTime));
        VxSdk::Utilities::StrCopySafe(clips[i].endTime, Utils::ConvertDateTimeToChar(newExport->Clips[i]->EndTime));
    }

    // Create a VxNewExport object using the settings contained in newExport and the VxNewExportClip that
    // was just created.
    VxSdk::VxNewExport vxExport;
    vxExport.format = (VxSdk::VxExportFormat::Value)newExport->Format;
    vxExport.clips = clips;
    vxExport.clipSize = clipSize;
    VxSdk::Utilities::StrCopySafe(vxExport.name, Utils::ConvertSysString(newExport->Name));
    // If the password field has a password set then the export will be password protected, if the password is not
    // set, the export will be public
    VxSdk::Utilities::StrCopySafe(vxExport.password, Utils::ConvertSysString(newExport->Password));

    CPPCli::Export^ retExport = nullptr;
    // Attempt to create the export
    VxSdk::IVxExport* exportItem = nullptr;
    VxSdk::VxResult::Value result = _system->CreateExport(vxExport, exportItem);

    // Unless there was an issue initiating the export the result should be VxSdk::VxResult::kOK
    if (result == VxSdk::VxResult::kOK) {
        // The exportItem returned from the system is the export initiated on the server and contains a lot of
        // helpful information about the export.
        retExport = gcnew CPPCli::Export(exportItem);
    }
    return retExport;
}

CPPCli::Results::Value CPPCli::VXSystem::CreateMonitor

(

NewMonitor^

newMonitor

)

Create a new monitor on the VideoXpert system.

Parameters

newMonitor

The new monitor to be added to the system.

Returns

The Result of creating the monitor.

Definition at line 293 of file VXSystem.cpp.

                                                                       {
    // Create a new monitor object and populate its fields using newMonitor
    VxSdk::VxNewMonitor vxNewMonitor;
    VxSdk::Utilities::StrCopySafe(vxNewMonitor.hostDeviceId, Utils::ConvertSysString(newMonitor->HostDeviceId));
    VxSdk::Utilities::StrCopySafe(vxNewMonitor.name, Utils::ConvertSysString(newMonitor->Name));
    vxNewMonitor.layout = (VxSdk::VxCellLayout::Value)newMonitor->Layout;
    vxNewMonitor.number = newMonitor->Number;

    // Make the call to add the monitor into VideoXpert
    VxSdk::VxResult::Value result = _system->CreateMonitor(vxNewMonitor);
    // Unless there was an issue creating the monitor the result should be VxSdk::VxResult::kOK
    return CPPCli::Results::Value(result);
}

CPPCli::Notification CPPCli::VXSystem::CreateNotification

(

CPPCli::NewNotification^

newNotification

)

Create a new notification on the VideoXpert system.

Parameters

newNotification

The new notification to be added to the system.

Returns

nullptr if it fails, else the new notification.

Definition at line 307 of file VXSystem.cpp.

                                                                                             {
    auto roles = newNotification->Roles;

    // Create a notification object and populate its fields using newNotification
    VxSdk::VxNewNotification vxNotification;
    vxNotification.roleIdSize = static_cast<int>(roles->Count);
    if (vxNotification.roleIdSize > 0) {
        vxNotification.roleIds = new char*[vxNotification.roleIdSize];
        for (int i = 0; i < vxNotification.roleIdSize; i++) {
            int idLength = roles[i]->Id->Length + 1;
            vxNotification.roleIds[i] = new char[idLength];
            VxSdk::Utilities::StrCopySafe(vxNotification.roleIds[i], Utils::ConvertSysString(roles[i]->Id), idLength);
        }
    }

    CPPCli::Notification^ retNotification = nullptr;
    // Make the call to add the notification into VideoXpert
    VxSdk::IVxNotification* notificationItem = nullptr;
    VxSdk::VxResult::Value result = _system->AddNotification(vxNotification, notificationItem);

    // Unless there was an issue adding the notification the result should be VxSdk::VxResult::kOK
    if (result == VxSdk::VxResult::kOK) {
        retNotification = gcnew CPPCli::Notification(notificationItem);
    }
    return retNotification;
}

CPPCli::QuickLog CPPCli::VXSystem::CreateQuickLog

(

)

Create a new quick log on the VideoXpert system.

Returns

nullptr if it fails, else the new log.

Definition at line 334 of file VXSystem.cpp.

                                               {
    CPPCli::QuickLog^ retQuickLog = nullptr;
    VxSdk::IVxQuickLog* quickLogItem = nullptr;
    // Attempt to create the quick log
    VxSdk::VxResult::Value result = _system->CreateQuickLog(quickLogItem);
    // Unless there was an issue creating the quick log the result should be VxSdk::VxResult::kOK
    if (result == VxSdk::VxResult::kOK) {
        // The quickLogItem returned from the system is the quick log initiated on the server and contains the
        // information needed to obtain the log data
        retQuickLog = gcnew CPPCli::QuickLog(quickLogItem);
    }
    return retQuickLog;
}

CPPCli::QuickReport CPPCli::VXSystem::CreateQuickReport

(

NewQuickReport^

newQuickReport

)

Create a new quick report on the VideoXpert system.

Parameters

newQuickReport

The new quick report to be created.

Returns

nullptr if it fails, else the new report.

Definition at line 348 of file VXSystem.cpp.

                                                                                   {
    // Create a VxNewQuickReport object
    VxSdk::VxNewQuickReport vxQuickReport;
    vxQuickReport.contentsSize = newQuickReport->Contents->Count;
    vxQuickReport.contents = new VxSdk::VxReportContent::Value[vxQuickReport.contentsSize];

    for (int i = 0; i < vxQuickReport.contentsSize; i++)
        vxQuickReport.contents[i] = (VxSdk::VxReportContent::Value)newQuickReport->Contents[i];

    if (newQuickReport->EndTime != System::DateTime::MinValue)
        VxSdk::Utilities::StrCopySafe(vxQuickReport.endTime, Utils::ConvertDateTimeToChar(newQuickReport->EndTime));

    if (newQuickReport->StartTime != System::DateTime::MinValue)
        VxSdk::Utilities::StrCopySafe(vxQuickReport.startTime, Utils::ConvertDateTimeToChar(newQuickReport->StartTime));

    CPPCli::QuickReport^ retQuickReport = nullptr;
    VxSdk::IVxQuickReport* quickReportItem = nullptr;
    // Attempt to create the quick report
    VxSdk::VxResult::Value result = _system->CreateQuickReport(vxQuickReport, quickReportItem);
    // Unless there was an issue creating the quick report the result should be VxSdk::VxResult::kOK
    if (result == VxSdk::VxResult::kOK) {
        // The quickReportItem returned from the system is the quick report initiated on the server and contains the
        // information needed to obtain the report data
        retQuickReport = gcnew CPPCli::QuickReport(quickReportItem);
    }
    return retQuickReport;
}

CPPCli::Results::Value CPPCli::VXSystem::CreateTag

(

CPPCli::NewTag^

newTag

)

Create a new tag on the VideoXpert system.

Parameters

newTag

The new tag to be added to the system.

Returns

The Result of adding the tag.

Definition at line 376 of file VXSystem.cpp.

                                                                 {
    // Create a new tag object and populate its fields using newTag
    VxSdk::VxNewTag vxTag;
    VxSdk::Utilities::StrCopySafe(vxTag.name, Utils::ConvertSysString(newTag->Name));
    vxTag.isPublic = newTag->IsPublic;

    // Make the call to add the tag into VideoXpert
    VxSdk::VxResult::Value result = _system->AddTag(vxTag);
    // Unless there was an issue creating the tag the result should be VxSdk::VxResult::kOK
    return CPPCli::Results::Value(result);
}

CPPCli::Results::Value CPPCli::VXSystem::DecommissionDevice

(

CPPCli::Device^

device

)

Decommissions a device on the VideoXpert system.

Parameters

device

The device to decommission.

Returns

The Result of decommissioning the device.

Definition at line 388 of file VXSystem.cpp.

                                                                          {
    // Get the license object
    VxSdk::IVxLicense* license = nullptr;
    VxSdk::VxResult::Value result = _system->GetLicense(license);
    if (result != VxSdk::VxResult::kOK || license == nullptr)
        return (CPPCli::Results::Value)result;

    return (CPPCli::Results::Value)license->DecommissionDevice(*device->_device);
}

CPPCli::Results::Value CPPCli::VXSystem::DeleteBookmark

(

CPPCli::Bookmark^

bookmarkItem

)

Delete a bookmark from the VideoXpert system.

Parameters

bookmarkItem

The bookmark to be deleted from the system.

Returns

The Result of deleting the bookmark.

Definition at line 398 of file VXSystem.cpp.

                                                                              {
    // Create a bookmark object using the bookmarkItem
    VxSdk::IVxBookmark* delBookmark = bookmarkItem->_bookmark;

    // To delete a bookmark simply make a DeleteBookmark call
    VxSdk::VxResult::Value result = delBookmark->DeleteBookmark();
    // Unless there was an issue deleting the bookmark the result should be VxSdk::VxResult::kOK
    return CPPCli::Results::Value(result);
}

CPPCli::Results::Value CPPCli::VXSystem::DeleteDataObject

(

CPPCli::DataObject^

dataObjectItem

)

Delete a data object from the VideoXpert system.

Parameters

dataObject

The data object to be deleted from the system.

Returns

The Result of deleting the data object.

Definition at line 408 of file VXSystem.cpp.

                                                                                    {
    // Create a data object object using the dataObjectItem
    VxSdk::IVxDataObject* delDataObject = dataObjectItem->_dataObject;

    // To delete a data object simply make a DeleteTag call
    VxSdk::VxResult::Value result = delDataObject->DeleteDataObject();
    // Unless there was an issue deleting the data object the result should be VxSdk::VxResult::kOK
    return CPPCli::Results::Value(result);
}

CPPCli::Results::Value CPPCli::VXSystem::DeleteDevice

(

CPPCli::Device^

device

)

Delete a device and its hosted data sources and data storages from the VideoXpert system. If the device is assigned to a datastorage, it shall be unassigned.

Parameters

device

The device to be deleted.

Returns

The Result of deleting the device.

Definition at line 418 of file VXSystem.cpp.

                                                                    {
    // Create a device object
    VxSdk::IVxDevice* delDevice = device->_device;

    // To delete a device simply make a DeleteDevice call
    VxSdk::VxResult::Value result = delDevice->DeleteDevice();
    // Unless there was an issue deleting the device the result should be VxSdk::VxResult::kOK
    return CPPCli::Results::Value(result);
}

CPPCli::Results::Value CPPCli::VXSystem::DeleteDrawing

(

CPPCli::Drawing^

drawingItem

)

Delete a drawing from the VideoXpert system.

Parameters

drawingItem

The drawing to be deleted from the system.

Returns

The Result of deleting the drawing.

Definition at line 428 of file VXSystem.cpp.

                                                                           {
    // Create a drawing object using the drawingItem
    VxSdk::IVxDrawing* delDrawing = drawingItem->_drawing;

    // To delete a drawing simply make a DeleteDrawing call
    VxSdk::VxResult::Value result = delDrawing->DeleteDrawing();
    // Unless there was an issue deleting the drawing the result should be VxSdk::VxResult::kOK
    return CPPCli::Results::Value(result);
}

CPPCli::Results::Value CPPCli::VXSystem::DeleteExport

(

CPPCli::Export^

exportItem

)

Delete an export from the VideoXpert system.

Parameters

exportItem

The export to be deleted from the system.

Returns

The Result of deleting the export.

Definition at line 438 of file VXSystem.cpp.

                                                                        {
    // Create an export object using the exportItem
    VxSdk::IVxExport* delExport = exportItem->_export;

    // To delete an export simply make a DeleteExport call
    VxSdk::VxResult::Value result = delExport->DeleteExport();
    // Unless there was an issue deleting the export the result should be VxSdk::VxResult::kOK
    return CPPCli::Results::Value(result);
}

CPPCli::Results::Value CPPCli::VXSystem::DeleteManualRecording

(

CPPCli::ManualRecording^

manualRecordingItem

)

Delete a manual recording from the VideoXpert system.

Parameters

manualRecordingItem

The manual recording to be deleted from the system.

Returns

The Result of deleting the manual recording.

Definition at line 448 of file VXSystem.cpp.

                                                                                                   {
    // Create a manual recording object using the manualRecordingItem
    VxSdk::IVxManualRecording* delManualRecording = manualRecordingItem->_manualRecording;

    // To delete a manual recording simply make a DeleteManualRecording call
    VxSdk::VxResult::Value result = delManualRecording->DeleteManualRecording();
    // Unless there was an issue deleting the manual recording the result should be VxSdk::VxResult::kOK
    return CPPCli::Results::Value(result);
}

CPPCli::Results::Value CPPCli::VXSystem::DeleteNotification

(

CPPCli::Notification^

notificationItem

)

Delete a notification from the VideoXpert system.

Parameters

notificationItem

The notification to be deleted from the system.

Returns

The Result of deleting the notification.

Definition at line 458 of file VXSystem.cpp.

                                                                                          {
    // Create a notification object using the notificationItem
    VxSdk::IVxNotification* delNotification = notificationItem->_notification;

    // To delete a notification simply make a DeleteNotification call
    VxSdk::VxResult::Value result = delNotification->DeleteNotification();
    // Unless there was an issue deleting the notification the result should be VxSdk::VxResult::kOK
    return CPPCli::Results::Value(result);
}

CPPCli::Results::Value CPPCli::VXSystem::DeleteRole

(

CPPCli::Role^

roleItem

)

Delete a role from the VideoXpert system.

Parameters

role	The role to be deleted from the system.

Returns

The Result of deleting the role.

Definition at line 468 of file VXSystem.cpp.

                                                                  {
    // Create a role object using the roleItem
    VxSdk::IVxRole* delRole = roleItem->_role;

    // To delete a role simply make a DeleteRole call
    VxSdk::VxResult::Value result = delRole->DeleteRole();
    // Unless there was an issue deleting the role the result should be VxSdk::VxResult::kOK
    return CPPCli::Results::Value(result);
}

CPPCli::Results::Value CPPCli::VXSystem::DeleteSchedule

(

CPPCli::Schedule^

scheduleItem

)

Delete a schedule from the VideoXpert system.

Parameters

scheduleItem

The schedule to be deleted from the system.

Returns

The Result of deleting the schedule.

Definition at line 478 of file VXSystem.cpp.

                                                                              {
    // Create a schedule object using the scheduleItem
    VxSdk::IVxSchedule* delSchedule = scheduleItem->_schedule;

    // To delete a schedule simply make a DeleteSchedule call
    VxSdk::VxResult::Value result = delSchedule->DeleteSchedule();
    // Unless there was an issue deleting the schedule the result should be VxSdk::VxResult::kOK
    return CPPCli::Results::Value(result);
}

CPPCli::Results::Value CPPCli::VXSystem::DeleteSituation

(

CPPCli::Situation^

situationItem

)

Delete an existing situation from the system.

Parameters

situationItem

The situation to be deleted from the system.

Returns

The Result of deleting the situation.

Definition at line 488 of file VXSystem.cpp.

                                                                                 {
    // Create a situation object using the situationItem
    VxSdk::IVxSituation* delSituation = situationItem->_situation;

    // To delete a situation simply make a DeleteSituation call
    VxSdk::VxResult::Value result = delSituation->DeleteSituation();
    // Unless there was an issue deleting the situation the result should be VxSdk::VxResult::kOK
    return CPPCli::Results::Value(result);
}

CPPCli::Results::Value CPPCli::VXSystem::DeleteTag

(

CPPCli::Tag^

tagItem

)

Delete a tag from the VideoXpert system.

Parameters

tagItem

The tag to be deleted from the system.

Returns

The Result of deleting the tag.

Definition at line 498 of file VXSystem.cpp.

                                                               {
    // Create a tag object using the tagItem
    VxSdk::IVxTag* delTag = tagItem->_tag;

    // To delete a tag simply make a DeleteTag call
    VxSdk::VxResult::Value result = delTag->DeleteTag();
    // Unless there was an issue deleting the tag the result should be VxSdk::VxResult::kOK
    return CPPCli::Results::Value(result);
}

CPPCli::Results::Value CPPCli::VXSystem::DeleteUser

(

CPPCli::User^

userItem

)

Delete a user from the VideoXpert system.

Parameters

user	The user to be deleted from the system.

Returns

The Result of deleting the user.

Definition at line 508 of file VXSystem.cpp.

                                                                  {
    // Create a user object using the tagItem
    VxSdk::IVxUser* delUser = userItem->_user;

    // To delete a user simply make a DeleteUser call
    VxSdk::VxResult::Value result = delUser->DeleteUser();
    // Unless there was an issue deleting the user the result should be VxSdk::VxResult::kOK
    return CPPCli::Results::Value(result);
}

delegate void CPPCli::VXSystem::EventCallbackDelegate

(

VxSdk::IVxEvent *

vxEvent

)

The native event callback delegate.

Parameters

vxEvent

The event sent from system.

delegate void CPPCli::VXSystem::EventDelegate

(

Event^

vxEvent

)

The managed event delegate.

Parameters

vxEvent

The event sent from the system as a managed type.

List< CPPCli::AlarmInput^ > CPPCli::VXSystem::GetAlarmInputs

(

)

Get the alarm inputs from the VideoXpert system.

Returns

A List containing the alarm inputs on the system.

Definition at line 518 of file VXSystem.cpp.

                                                        {
    // Create a list of managed alarm input objects
    List<AlarmInput^>^ mlist = gcnew List<AlarmInput^>();
    // Create a collection of unmanaged alarm input objects
    VxSdk::VxCollection<VxSdk::IVxAlarmInput**> alarmInputs;

    // Make the GetAlarmInputs call, which will return with the total count of alarm inputs, this allows the client to allocate memory.
    VxSdk::VxResult::Value result = _system->GetAlarmInputs(alarmInputs);
    // Unless there are no alarm inputs on the system, this should return VxSdk::VxResult::kInsufficientSize
    if (result == VxSdk::VxResult::kInsufficientSize) {
        // An array of pointers is allocated using the size returned by the previous GetAlarmInputs call
        alarmInputs.collection = new VxSdk::IVxAlarmInput*[alarmInputs.collectionSize];
        result = _system->GetAlarmInputs(alarmInputs);
        // The result should now be kOK since we have allocated enough space
        if (result == VxSdk::VxResult::kOK) {
            for (int i = 0; i < alarmInputs.collectionSize; i++)
                mlist->Add(gcnew CPPCli::AlarmInput(alarmInputs.collection[i]));
        }
        // Remove the memory we previously allocated to the collection
        delete[] alarmInputs.collection;
    }
    return mlist;
}

List< CPPCli::Bookmark^ > CPPCli::VXSystem::GetBookmarks

(

)

Get the bookmarks from the VideoXpert system.

Returns

A List containing the bookmarks on the system.

Definition at line 542 of file VXSystem.cpp.

                                                    {
    // Create a list of managed bookmark objects
    List<CPPCli::Bookmark^>^ mlist = gcnew List<CPPCli::Bookmark^>();
    // Create a collection of unmanaged bookmark objects
    VxSdk::VxCollection<VxSdk::IVxBookmark**> bookmarks;

    // Make the GetBookmarks call, which will return with the total bookmark count, this allows the client to allocate memory
    VxSdk::VxResult::Value result = _system->GetBookmarks(bookmarks);
    // The result should be kInsufficientSize if the number of bookmarks on the system are greater than 0
    if (result == VxSdk::VxResult::kInsufficientSize) {
        // Allocate enough space for the IVxBookmark collection
        bookmarks.collection = new VxSdk::IVxBookmark*[bookmarks.collectionSize];
        result = _system->GetBookmarks(bookmarks);
        // The result should now be kOK since we have allocated enough space
        if (result == VxSdk::VxResult::kOK) {
            for (int i = 0; i < bookmarks.collectionSize; i++) {
                mlist->Add(gcnew CPPCli::Bookmark(bookmarks.collection[i]));
            }
        }
        // Remove the memory we previously allocated to the collection
        delete[] bookmarks.collection;
    }
    return mlist;
}

List< CPPCli::DataObject^ > CPPCli::VXSystem::GetDataObjects

(

)

Get the data objects from the VideoXpert system.

Returns

A List containing the data objects on the system.

Definition at line 567 of file VXSystem.cpp.

                                                        {
    // Create a list of managed data objects
    List<CPPCli::DataObject^>^ mlist = gcnew List<CPPCli::DataObject^>();
    // Create a collection of unmanaged data objects
    VxSdk::VxCollection<VxSdk::IVxDataObject**> dataObjects;

    // Make the GetDataObjects call, which will return with the total data object count, this allows the client to allocate memory
    VxSdk::VxResult::Value result = _system->GetDataObjects(dataObjects);
    // The result should be kInsufficientSize if the number of data objects on the system are greater than 0
    if (result == VxSdk::VxResult::kInsufficientSize) {
        // Allocate enough space for the IVxDataObject collection
        dataObjects.collection = new VxSdk::IVxDataObject*[dataObjects.collectionSize];
        result = _system->GetDataObjects(dataObjects);
        // The result should now be kOK since we have allocated enough space
        if (result == VxSdk::VxResult::kOK) {
            for (int i = 0; i < dataObjects.collectionSize; i++) {
                mlist->Add(gcnew CPPCli::DataObject(dataObjects.collection[i]));
            }
        }
        // Remove the memory we previously allocated to the collection
        delete[] dataObjects.collection;
    }
    return mlist;
}

Collections::Generic::List< CPPCli::DataSource^ > CPPCli::VXSystem::GetDataSources

(

)

Get the data sources from the VideoXpert system.

Returns

A List containing the data sources on the system.

Definition at line 592 of file VXSystem.cpp.

                                                                          {
    // Create a list of managed data source objects
    List<CPPCli::DataSource^>^ mlist = gcnew List<CPPCli::DataSource^>();
    // Create a collection of unmanaged data source objects
    VxSdk::VxCollection<VxSdk::IVxDataSource**> dataSources;

    // Make the GetDataSources call, which will return with the total data source count, this allows the client to allocate memory.
    VxSdk::VxResult::Value result = _system->GetDataSources(dataSources);
    // Unless there are no data sources on the system, this should return VxSdk::VxResult::kInsufficientSize
    if (result == VxSdk::VxResult::kInsufficientSize) {
        // Allocate enough space for the IVxDataSource collection
        dataSources.collection = new VxSdk::IVxDataSource*[dataSources.collectionSize];
        result = _system->GetDataSources(dataSources);
        // The result should now be kOK since we have allocated enough space
        if (result == VxSdk::VxResult::kOK) {
            for (int i = 0; i < dataSources.collectionSize; i++)
                mlist->Add(gcnew CPPCli::DataSource(dataSources.collection[i]));
        }
        // Remove the memory we previously allocated to the collection
        delete[] dataSources.collection;
    }
    return mlist;
}

List< CPPCli::DataStorage^ > CPPCli::VXSystem::GetDataStorages

(

)

Get the data storages residing on the system.

Returns

A List containing the data storages.

Definition at line 616 of file VXSystem.cpp.

                                                          {
    // Create a list of managed data storage objects
    List<CPPCli::DataStorage^>^ mlist = gcnew List<CPPCli::DataStorage^>();
    // Create a collection of unmanaged data storage objects
    VxSdk::VxCollection<VxSdk::IVxDataStorage**> dataStorages;

    // Make the GetDataStorages call, which will return with the total storage count, this allows the client to allocate memory
    VxSdk::VxResult::Value result = _system->GetDataStorages(dataStorages);
    // The result should be kInsufficientSize if the number of data storages on the system are greater than 0
    if (result == VxSdk::VxResult::kInsufficientSize) {
        // Allocate enough space for the IVxDataStorage collection
        dataStorages.collection = new VxSdk::IVxDataStorage*[dataStorages.collectionSize];
        result = _system->GetDataStorages(dataStorages);
        // The result should now be kOK since we have allocated enough space
        if (result == VxSdk::VxResult::kOK) {
            for (int i = 0; i < dataStorages.collectionSize; i++) {
                mlist->Add(gcnew CPPCli::DataStorage(dataStorages.collection[i]));
            }
        }
        // Remove the memory we previously allocated to the collection
        delete[] dataStorages.collection;
    }
    return mlist;
}

List< CPPCli::DeviceAssignment^ > CPPCli::VXSystem::GetDeviceAssignments

(

)

Get the device assignments residing on the system.

Returns

A List containing the device assignments.

Definition at line 641 of file VXSystem.cpp.

                                                                    {
    // Create a list of managed device assignment objects
    List<DeviceAssignment^>^ mlist = gcnew List<DeviceAssignment^>();
    // Create a collection of unmanaged device assignment objects
    VxSdk::VxCollection<VxSdk::IVxDeviceAssignment**> deviceAssignments;

    // Make the GetDeviceAssignments call, which will return with the total count of device assignments, this allows the client to allocate memory.
    VxSdk::VxResult::Value result = _system->GetDeviceAssignments(deviceAssignments);
    // Unless there are no device assignments on the system, this should return VxSdk::VxResult::kInsufficientSize
    if (result == VxSdk::VxResult::kInsufficientSize) {
        // An array of pointers is allocated using the size returned by the previous GetDeviceAssignments call
        deviceAssignments.collection = new VxSdk::IVxDeviceAssignment*[deviceAssignments.collectionSize];
        result = _system->GetDeviceAssignments(deviceAssignments);
        // The result should now be kOK since we have allocated enough space
        if (result == VxSdk::VxResult::kOK) {
            for (int i = 0; i < deviceAssignments.collectionSize; i++)
                mlist->Add(gcnew CPPCli::DeviceAssignment(deviceAssignments.collection[i]));
        }
        // Remove the memory we previously allocated to the collection
        delete[] deviceAssignments.collection;
    }
    return mlist;
}

Collections::Generic::List< CPPCli::Device^ > CPPCli::VXSystem::GetDevices

(

)

Get the devices from the VideoXpert system.

Returns

A List containing the devices on the system.

Definition at line 665 of file VXSystem.cpp.

                                                                  {
    // Create a list of managed device objects
    List<CPPCli::Device^>^ mlist = gcnew List<CPPCli::Device^>();
    // Create a collection of unmanaged device objects
    VxSdk::VxCollection<VxSdk::IVxDevice**> devices;

    // Make the GetDevices call, which will return with the total device count, this allows the client to allocate memory.
    VxSdk::VxResult::Value result = _system->GetDevices(devices);
    // Unless there are no devices on the system, this should return VxSdk::VxResult::kInsufficientSize
    if (result == VxSdk::VxResult::kInsufficientSize) {
        // Allocate enough space for the IVxDevice collection
        devices.collection = new VxSdk::IVxDevice*[devices.collectionSize];
        result = _system->GetDevices(devices);
        // The result should now be kOK since we have allocated enough space
        if (result == VxSdk::VxResult::kOK) {
            for (int i = 0; i < devices.collectionSize; i++)
                mlist->Add(gcnew CPPCli::Device(devices.collection[i]));
        }
        // Remove the memory we previously allocated to the collection
        delete[] devices.collection;
    }
    return mlist;
}

List< CPPCli::Drawing^ > CPPCli::VXSystem::GetDrawings

(

)

Get the drawings from the VideoXpert system.

Returns

A List containing the drawings on the system.

Definition at line 737 of file VXSystem.cpp.

                                                  {
    // Create a list of managed drawing objects
    List<CPPCli::Drawing^>^ mlist = gcnew List<CPPCli::Drawing^>();
    // Create a collection of unmanaged drawing objects
    VxSdk::VxCollection<VxSdk::IVxDrawing**> drawings;

    // Make the GetDrawings call, which will return with the total drawing count, this allows the client to allocate memory
    VxSdk::VxResult::Value result = _system->GetDrawings(drawings);
    // The result should be kInsufficientSize if the number of drawings on the system are greater than 0
    if (result == VxSdk::VxResult::kInsufficientSize) {
        // Allocate enough space for the IVxDrawing collection
        drawings.collection = new VxSdk::IVxDrawing*[drawings.collectionSize];
        result = _system->GetDrawings(drawings);
        // The result should now be kOK since we have allocated enough space
        if (result == VxSdk::VxResult::kOK) {
            for (int i = 0; i < drawings.collectionSize; i++) {
                mlist->Add(gcnew CPPCli::Drawing(drawings.collection[i]));
            }
        }
        // Remove the memory we previously allocated to the collection
        delete[] drawings.collection;
    }
    return mlist;
}

List< CPPCli::Export^ > CPPCli::VXSystem::GetExports

(

)

Get the exports residing on the system.

Returns

A List containing the exports on the system.

Definition at line 762 of file VXSystem.cpp.

                                                {
    // Create a list of managed export objects
    List<CPPCli::Export^>^ mlist = gcnew List<CPPCli::Export^>();
    // Create a collection of unmanaged export objects
    VxSdk::VxCollection<VxSdk::IVxExport**> exports;

    // Make the GetExports call, which will return with the total export count, this allows the client to allocate memory.
    VxSdk::VxResult::Value result = _system->GetExports(exports);
    // Unless there are no exports on the system, this should return VxSdk::VxResult::kInsufficientSize
    if (result == VxSdk::VxResult::kInsufficientSize) {
        // Allocate enough space for the IVxExport collection
        exports.collection = new VxSdk::IVxExport*[exports.collectionSize];
        result = _system->GetExports(exports);
        // The result should now be kOK since we have allocated enough space
        if (result == VxSdk::VxResult::kOK) {
            for (int i = 0; i < exports.collectionSize; i++)
                mlist->Add(gcnew CPPCli::Export(exports.collection[i]));
        }
        // Remove the memory we previously allocated to the collection
        delete[] exports.collection;
    }
    return mlist;
}

CPPCli::License CPPCli::VXSystem::GetLicense

(

)

Get the license from the system.

Returns

The system license.

Definition at line 786 of file VXSystem.cpp.

                                          {
    // Get the license object
    VxSdk::IVxLicense* license = nullptr;
    VxSdk::VxResult::Value result = _system->GetLicense(license);

    // Return the license if GetLicense was successful
    if (result == VxSdk::VxResult::kOK)
        return gcnew CPPCli::License(license);

    return nullptr;
}

Collections::Generic::List< CPPCli::ManualRecording^ > CPPCli::VXSystem::GetManualRecordings

(

)

Gets the manual recordings residing on the system.

Returns

A List containing the manual recordings on the system.

Definition at line 689 of file VXSystem.cpp.

                                                                                    {
    // Create a list of managed manual recording objects
    List<CPPCli::ManualRecording^>^ mlist = gcnew List<CPPCli::ManualRecording^>();
    // Create a collection of unmanaged manual recording objects
    VxSdk::VxCollection<VxSdk::IVxManualRecording**> manualRecordings;

    // Make the GetManualRecordings call, which will return with the total manual recording count, this allows the client to allocate memory.
    VxSdk::VxResult::Value result = _system->GetManualRecordings(manualRecordings);
    // Unless there are no manual recordings on the system, this should return VxSdk::VxResult::kInsufficientSize
    if (result == VxSdk::VxResult::kInsufficientSize) {
        // Allocate enough space for the IVxManualRecording collection
        manualRecordings.collection = new VxSdk::IVxManualRecording*[manualRecordings.collectionSize];
        result = _system->GetManualRecordings(manualRecordings);
        // The result should now be kOK since we have allocated enough space
        if (result == VxSdk::VxResult::kOK) {
            for (int i = 0; i < manualRecordings.collectionSize; i++)
                mlist->Add(gcnew CPPCli::ManualRecording(manualRecordings.collection[i]));
        }
        // Remove the memory we previously allocated to the collection
        delete[] manualRecordings.collection;
    }
    return mlist;
}

List< CPPCli::Monitor^ > CPPCli::VXSystem::GetMonitors

(

)

Get the monitors residing on the system.

Returns

A List containing the monitors on the system.

Definition at line 713 of file VXSystem.cpp.

                                                  {
    // Create a list of managed monitor objects
    List<CPPCli::Monitor^>^ mlist = gcnew List<CPPCli::Monitor^>();
    // Create a collection of unmanaged monitor objects
    VxSdk::VxCollection<VxSdk::IVxMonitor**> monitors;

    // Make the GetExports call, which will return with the total export count, this allows the client to allocate memory.
    VxSdk::VxResult::Value result = _system->GetMonitors(monitors);
    // Unless there are no exports on the system, this should return VxSdk::VxResult::kInsufficientSize
    if (result == VxSdk::VxResult::kInsufficientSize) {
        // Allocate enough space for the IVxExport collection
        monitors.collection = new VxSdk::IVxMonitor*[monitors.collectionSize];
        result = _system->GetMonitors(monitors);
        // The result should now be kOK since we have allocated enough space
        if (result == VxSdk::VxResult::kOK) {
            for (int i = 0; i < monitors.collectionSize; i++)
                mlist->Add(gcnew CPPCli::Monitor(monitors.collection[i]));
        }
        // Remove the memory we previously allocated to the collection
        delete[] monitors.collection;
    }
    return mlist;
}

List< CPPCli::Notification^ > CPPCli::VXSystem::GetNotifications

(

)

Get the notifications from the VideoXpert system.

Returns

A List containing the notifications on the system.

Definition at line 798 of file VXSystem.cpp.

                                                            {
    // Create a list of managed notification objects
    List<CPPCli::Notification^>^ mlist = gcnew List<CPPCli::Notification^>();
    // Create a collection of unmanaged notification objects
    VxSdk::VxCollection<VxSdk::IVxNotification**> notifications;

    // Make the GetNotifications call, which will return with the total notification count, this allows the client to allocate memory
    VxSdk::VxResult::Value result = _system->GetNotifications(notifications);
    // The result should be kInsufficientSize if the number of notifications on the system are greater than 0
    if (result == VxSdk::VxResult::kInsufficientSize) {
        // Allocate enough space for the IVxNotification collection
        notifications.collection = new VxSdk::IVxNotification*[notifications.collectionSize];
        result = _system->GetNotifications(notifications);
        // The result should now be kOK since we have allocated enough space
        if (result == VxSdk::VxResult::kOK) {
            for (int i = 0; i < notifications.collectionSize; i++) {
                mlist->Add(gcnew CPPCli::Notification(notifications.collection[i]));
            }
        }
        // Remove the memory we previously allocated to the collection
        delete[] notifications.collection;
    }
    return mlist;
}

List< CPPCli::RelayOutput^ > CPPCli::VXSystem::GetRelayOutputs

(

)

Get the relay outputs from the VideoXpert system.

Returns

A List containing the relay outputs on the system.

Definition at line 823 of file VXSystem.cpp.

                                                          {
    // Create a list of managed relay output objects
    List<RelayOutput^>^ mlist = gcnew List<RelayOutput^>();
    // Create a collection of unmanaged relay output objects
    VxSdk::VxCollection<VxSdk::IVxRelayOutput**> relayOutputs;

    // Make the GetRelayOutputs call, which will return with the total count of relay outputs, this allows the client to allocate memory.
    VxSdk::VxResult::Value result = _system->GetRelayOutputs(relayOutputs);
    // Unless there are no relay outputs on the system, this should return VxSdk::VxResult::kInsufficientSize
    if (result == VxSdk::VxResult::kInsufficientSize) {
        // An array of pointers is allocated using the size returned by the previous GetRelayOutputs call
        relayOutputs.collection = new VxSdk::IVxRelayOutput*[relayOutputs.collectionSize];
        result = _system->GetRelayOutputs(relayOutputs);
        // The result should now be kOK since we have allocated enough space
        if (result == VxSdk::VxResult::kOK) {
            for (int i = 0; i < relayOutputs.collectionSize; i++)
                mlist->Add(gcnew CPPCli::RelayOutput(relayOutputs.collection[i]));
        }
        // Remove the memory we previously allocated to the collection
        delete[] relayOutputs.collection;
    }
    return mlist;
}

List< CPPCli::Role^ > CPPCli::VXSystem::GetRoles

(

)

Get the roles from the VideoXpert system.

Returns

A List containing the roles on the system.

Definition at line 847 of file VXSystem.cpp.

                                            {
    // Create a list of managed role objects
    List<CPPCli::Role^>^ mlist = gcnew List<CPPCli::Role^>();
    // Create a collection of unmanaged role objects
    VxSdk::VxCollection<VxSdk::IVxRole**> roles;

    // Make the GetRoles call, which will return with the total role count, this allows the client to allocate memory
    VxSdk::VxResult::Value result = _system->GetRoles(roles);
    // The result should be kInsufficientSize if the number of roles on the system are greater than 0
    if (result == VxSdk::VxResult::kInsufficientSize) {
        // Allocate enough space for the IVxRole collection
        roles.collection = new VxSdk::IVxRole*[roles.collectionSize];
        result = _system->GetRoles(roles);
        // The result should now be kOK since we have allocated enough space
        if (result == VxSdk::VxResult::kOK) {
            for (int i = 0; i < roles.collectionSize; i++) {
                mlist->Add(gcnew CPPCli::Role(roles.collection[i]));
            }
        }
        // Remove the memory we previously allocated to the collection
        delete[] roles.collection;
    }
    return mlist;
}

List< CPPCli::Schedule^ > CPPCli::VXSystem::GetSchedules

(

)

Get the schedules from the VideoXpert system.

Returns

A List containing the schedules on the system.

Definition at line 872 of file VXSystem.cpp.

                                                    {
    // Create a list of managed schedule objects
    List<CPPCli::Schedule^>^ mlist = gcnew List<CPPCli::Schedule^>();
    // Create a collection of unmanaged schedule objects
    VxSdk::VxCollection<VxSdk::IVxSchedule**> schedules;

    // Make the GetSchedules call, which will return with the total schedule count, this allows the client to allocate memory
    VxSdk::VxResult::Value result = _system->GetSchedules(schedules);
    // The result should be kInsufficientSize if the number of schedules on the system are greater than 0
    if (result == VxSdk::VxResult::kInsufficientSize) {
        // Allocate enough space for the IVxSchedule collection
        schedules.collection = new VxSdk::IVxSchedule*[schedules.collectionSize];
        result = _system->GetSchedules(schedules);
        // The result should now be kOK since we have allocated enough space
        if (result == VxSdk::VxResult::kOK) {
            for (int i = 0; i < schedules.collectionSize; i++) {
                mlist->Add(gcnew CPPCli::Schedule(schedules.collection[i]));
            }
        }
        // Remove the memory we previously allocated to the collection
        delete[] schedules.collection;
    }
    return mlist;
}

List< CPPCli::Situation^ > CPPCli::VXSystem::GetSituations

(

)

Get the situations residing on the system.

Returns

A List containing the situations on the system.

Definition at line 897 of file VXSystem.cpp.

                                                      {
    // Create a list of managed situation objects
    List<CPPCli::Situation^>^ mlist = gcnew List<CPPCli::Situation^>();
    // Create a collection of unmanaged situation objects
    VxSdk::VxCollection<VxSdk::IVxSituation**> situations;

    // Make the GetSituations call, which will return with the total situation count, this allows the client to allocate memory.
    VxSdk::VxResult::Value result = _system->GetSituations(situations);
    // The result should be kInsufficientSize if the number of situations on the system are greater than 0 (always)
    if (result == VxSdk::VxResult::kInsufficientSize) {
        // Allocate enough space for the IVxSituation collection
        situations.collection = new VxSdk::IVxSituation*[situations.collectionSize];
        result = _system->GetSituations(situations);
        // The result should now be kOK since we have allocated enough space
        if (result == VxSdk::VxResult::kOK) {
            for (int i = 0; i < situations.collectionSize; i++) {
                mlist->Add(gcnew CPPCli::Situation(situations.collection[i]));
            }
        }
        // Remove the memory we previously allocated to the collection
        delete[] situations.collection;
    }
    return mlist;
}

List< CPPCli::Tag^ > CPPCli::VXSystem::GetTags

(

)

Get the tags from the VideoXpert system.

Returns

A List containing the tags on the system.

Definition at line 922 of file VXSystem.cpp.

                                          {
    // Create a list of managed tag objects
    List<CPPCli::Tag^>^ mlist = gcnew List<CPPCli::Tag^>();
    // Create a collection of unmanaged tag objects
    VxSdk::VxCollection<VxSdk::IVxTag**> tags;

    // Make the GetTags call, which will return with the total tag count, this allows the client to allocate memory
    VxSdk::VxResult::Value result = _system->GetTags(tags);
    // The result should be kInsufficientSize if the number of tags on the system are greater than 0
    if (result == VxSdk::VxResult::kInsufficientSize) {
        // Allocate enough space for the IVxTag collection
        tags.collection = new VxSdk::IVxTag*[tags.collectionSize];
        result = _system->GetTags(tags);
        // The result should now be kOK since we have allocated enough space
        if (result == VxSdk::VxResult::kOK) {
            for (int i = 0; i < tags.collectionSize; i++) {
                mlist->Add(gcnew CPPCli::Tag(tags.collection[i]));
            }
        }
        // Remove the memory we previously allocated to the collection
        delete[] tags.collection;
    }
    return mlist;
}

List< CPPCli::User^ > CPPCli::VXSystem::GetUsers

(

)

Get the users from the VideoXpert system.

Returns

A List containing the users on the system.

Definition at line 947 of file VXSystem.cpp.

                                            {
    // Create a list of managed tag objects
    List<CPPCli::User^>^ mlist = gcnew List<CPPCli::User^>();
    // Create a collection of unmanaged tag objects
    VxSdk::VxCollection<VxSdk::IVxUser**> users;

    // Make the GetTags call, which will return with the total tag count, this allows the client to allocate memory
    VxSdk::VxResult::Value result = _system->GetUsers(users);
    // The result should be kInsufficientSize if the number of tags on the system are greater than 0
    if (result == VxSdk::VxResult::kInsufficientSize) {
        // Allocate enough space for the IVxTag collection
        users.collection = new VxSdk::IVxUser*[users.collectionSize];
        result = _system->GetUsers(users);
        // The result should now be kOK since we have allocated enough space
        if (result == VxSdk::VxResult::kOK) {
            for (int i = 0; i < users.collectionSize; i++) {
                mlist->Add(gcnew CPPCli::User(users.collection[i]));
            }
        }
        // Remove the memory we previously allocated to the collection
        delete[] users.collection;
    }
    return mlist;
}

CPPCli::Results::Value CPPCli::VXSystem::InjectEvent

(

CPPCli::NewEvent^

newEvent

)

Insert a new event into the system.

Parameters

newEvent

The new event to be injected into the system.

Returns

The Result of injecting the event.

Definition at line 972 of file VXSystem.cpp.

                                                                       {
    // Create a new VxNewEvent object using the information contained in newEvent
    VxSdk::VxNewEvent vxEvent;
    VxSdk::Utilities::StrCopySafe(vxEvent.generatorDeviceId, Utils::ConvertSysString(newEvent->GeneratorDeviceId));
    VxSdk::Utilities::StrCopySafe(vxEvent.situationType, Utils::ConvertSysString(newEvent->SituationType));
    VxSdk::Utilities::StrCopySafe(vxEvent.sourceDeviceId, Utils::ConvertSysString(newEvent->SourceDeviceId));
    VxSdk::Utilities::StrCopySafe(vxEvent.time, Utils::ConvertDateTimeToChar(newEvent->Time));
    VxSdk::Utilities::StrCopySafe(vxEvent.sourceUserName, Utils::ConvertSysString(newEvent->SourceUserName));
    int size = vxEvent.propertySize = newEvent->Properties->Count;
    VxSdk::VxKvObject *kvObj = new VxSdk::VxKvObject[size];
    vxEvent.properties = kvObj;
    for (int i = 0; i < size; i++) {
        VxSdk::Utilities::StrCopySafe(vxEvent.properties[i].key, Utils::ConvertSysString(newEvent->Properties[i].Key));
        VxSdk::Utilities::StrCopySafe(vxEvent.properties[i].value, Utils::ConvertSysString(newEvent->Properties[i].Value));
    }

    // Make the call to insert the event into VideoXpert
    VxSdk::VxResult::Value result = _system->InsertEvent(vxEvent);
    // Unless there was an issue inserting the event the result should be VxSdk::VxResult::kOK
    if (result == VxSdk::VxResult::kOK) {
        // Remove the memory we previously allocated
        delete[] vxEvent.properties;
    }
    return CPPCli::Results::Value(result);
}

delegate void CPPCli::VXSystem::InternalEventCallbackDelegate

(

VxSdk::VxInternalEvent *

vxInternalEvent

)

The native internal event callback delegate.

Parameters

vxInternalEvent

The internal event sent from the VxSDK.

delegate void CPPCli::VXSystem::InternalEventDelegate

(

InternalEvent^

sdkEvent

)

The managed internal event delegate.

Parameters

sdkEvent

The internal event sent from the VxSDK as a managed type.

Results::Value CPPCli::VXSystem::Login	(	System::String^	username,
		System::String^	password
	)

Log in to the VideoXpert system.

Parameters

username	The user name to log in with.
password	The password to log in with.

Returns

The Result of the log in process.

Results::Value CPPCli::VXSystem::Login

(

System::String^

authToken

)

Log in to the VideoXpert system.

Parameters

authToken

The auth token

Returns

The Result of the log in process.

CPPCli::Results::Value CPPCli::VXSystem::Refresh

(

)

Update this instances properties.

Returns

The Result of updating the properties.

Definition at line 1035 of file VXSystem.cpp.

                                           {
    return (CPPCli::Results::Value)_system->Refresh();
}

CPPCli::Results::Value CPPCli::VXSystem::RemoveMonitor

(

CPPCli::Monitor^

monitorItem

)

Delete a monitor from the VideoXpert system.

Parameters

monitorItem

The monitor to be deleted from the system.

Returns

The Result of deleting the monitor.

Definition at line 1039 of file VXSystem.cpp.

                                                                           {
    // Create a monitor object using the monitorItem
    VxSdk::IVxMonitor* delMonitor = monitorItem->_monitor;

    // To delete a monitor simply make a RemoveMonitor call
    VxSdk::VxResult::Value result = delMonitor->RemoveMonitor();
    // Unless there was an issue deleting the monitor the result should be VxSdk::VxResult::kOK
    return CPPCli::Results::Value(result);
}

List< CPPCli::Event^ > CPPCli::VXSystem::SearchEvents	(	System::String^	type,
		System::DateTime^	start,
		System::DateTime^	end,
		int	index,
		int	count
	)

Search for events on the system.

Parameters

type	The situation type to search for.
start	The search start time.
end	The search end time.
index	The index of the first element returned in this page of the collection.
count	The maximum number of items to return in a page.

Returns

A List containing matching events on the system.

Definition at line 1049 of file VXSystem.cpp.

                                                                                                                                     {
    // Create a list of managed event objects
    List<CPPCli::Event^>^ mlist = gcnew List<CPPCli::Event^>();
    // Create a collection of unmanaged event objects
    VxSdk::VxCollection<VxSdk::IVxEvent**> events;

    events.startIndex = index;
    events.filterSize = 4;
    VxSdk::VxCollectionFilter filters[4];
    events.filters = filters;
    events.filters[0].key = VxSdk::VxCollectionFilterItem::kSituationType;
    VxSdk::Utilities::StrCopySafe(events.filters[0].value, Utils::ConvertSysString(type));
    events.filters[1].key = VxSdk::VxCollectionFilterItem::kSearchStartTime;
    VxSdk::Utilities::StrCopySafe(events.filters[1].value, CPPCli::Utils::ConvertDateTimeToChar(*start));
    events.filters[2].key = VxSdk::VxCollectionFilterItem::kSearchEndTime;
    VxSdk::Utilities::StrCopySafe(events.filters[2].value, CPPCli::Utils::ConvertDateTimeToChar(*end));
    events.filters[3].key = VxSdk::VxCollectionFilterItem::kCount;
    VxSdk::Utilities::StrCopySafe(events.filters[3].value, Utils::ConvertSysString(count.ToString()));

    // Make the GetEvents call, which will return with the total event count, this allows the client to allocate memory.
    VxSdk::VxResult::Value result = _system->GetEvents(events);
    // The result should be kInsufficientSize if the number of events on the system are greater than 0 (always)
    if (result == VxSdk::VxResult::kInsufficientSize) {
        // Allocate enough space for the IVxEvent collection
        events.collection = new VxSdk::IVxEvent*[events.collectionSize];
        result = _system->GetEvents(events);
        // The result should now be kOK since we have allocated enough space
        if (result == VxSdk::VxResult::kOK) {
            for (int i = 0; i < events.collectionSize; i++) {
                mlist->Add(gcnew CPPCli::Event(events.collection[i]));
            }
        }
        // Remove the memory we previously allocated to the collection
        delete[] events.collection;
    }
    return mlist;
}

CPPCli::Results::Value CPPCli::VXSystem::SubscribeToEventsByType	(	EventDelegate^	eventDelegate,
		System::Collections::Generic::List< Situation^ >^	situations
	)

Subscribe to system events by situation type, regardless of its notification setting.

Parameters

eventDelegate	The event delegate to be used when an event is received.
situations	A List of situations to subscribe to.

Returns

The Result of subscribing.

Definition at line 1087 of file VXSystem.cpp.

                                                                                                                                   {
    VxSdk::VxCollection<VxSdk::IVxSituation**> situationCollection;
    situationCollection.collectionSize = situations->Count;
    situationCollection.collection = new VxSdk::IVxSituation*[situationCollection.collectionSize];

    // Add the situations to subscribe to
    for (int i = 0; i < situations->Count; i++)
        situationCollection.collection[i] = situations[i]->_situation;

    // Subscribe to the system events using the situation types
    VxSdk::VxResult::Value result = _system->StartNotifications(
        VxSdk::VxEventCallback(Marshal::GetFunctionPointerForDelegate(_callback).ToPointer()), situationCollection);

    // Add a new subscription to the EventDelegate
    _systemEvent += eventDelegate;
    // Unless there was an issue subscribing the result should be VxSdk::VxResult::kOK
    return CPPCli::Results::Value(result);
}

Member Data Documentation

EventCallbackDelegate ^ CPPCli::VXSystem::_callback

package

Definition at line 560 of file VXSystem.h.

InternalEventCallbackDelegate ^ CPPCli::VXSystem::_internalCallback

package

Definition at line 561 of file VXSystem.h.

VxSdk::VxLoginInfo* CPPCli::VXSystem::_loginInfo

package

Definition at line 562 of file VXSystem.h.

InternalEventDelegate ^ CPPCli::VXSystem::_sdkEvent

staticpackage

Definition at line 564 of file VXSystem.h.

VxSdk::IVxSystem* CPPCli::VXSystem::_system

package

Definition at line 559 of file VXSystem.h.

EventDelegate ^ CPPCli::VXSystem::_systemEvent

staticpackage

Definition at line 563 of file VXSystem.h.

Property Documentation

Configuration:: Cluster^ CPPCli::VXSystem::ClusterConfig

get

Gets the cluster configuration from the VideoXpert system.

The cluster configuration.

Definition at line 488 of file VXSystem.h.

User^ CPPCli::VXSystem::Currentuser

get

Gets the user currently accessing the VideoXpert system.

The current user.

Definition at line 496 of file VXSystem.h.

SearchStatus CPPCli::VXSystem::DeviceSearchStatus

get

Gets the current SearchStatus of an AutoAddDevices search.

The current SearchStatus of an AutoAddDevices search.

Definition at line 504 of file VXSystem.h.

CPPCli:: Device^ CPPCli::VXSystem::HostDevice

get

Gets the device that hosts this system.

The host device.

Definition at line 516 of file VXSystem.h.

System:: String^ CPPCli::VXSystem::Id

get

Gets the unique identifier of the VideoXpert system.

The unique identifier.

Definition at line 525 of file VXSystem.h.

System:: String^ CPPCli::VXSystem::Name

getset

Gets the friendly name of the VideoXpert system.

The friendly name.

Definition at line 533 of file VXSystem.h.

Event Documentation

InternalEventDelegate^ CPPCli::VXSystem::InternalEvent

addremove

InternalEvent is raised whenever a new internal event is sent from the VxSDK.

Definition at line 553 of file VXSystem.h.

EventDelegate^ CPPCli::VXSystem::SystemEvent

addremove

SystemEvent is raised whenever a new event is created on the system.

Definition at line 545 of file VXSystem.h.

---

The documentation for this class was generated from the following files:

• C:/Git/VxSDK-Samples/CSharpSample/CSharpWrapper/Include/VXSystem.h
• C:/Git/VxSDK-Samples/CSharpSample/CSharpWrapper/Source/VXSystem.cpp