/// <summary>Increase the data length and fill the new data with a given value</summary>
/// <param name="data">The data object</param>
/// <param name="extraLength">How much to extend the data length by</param>
/// <param name="fillWith">The value to fill the new bytes with</param>
/// <returns>`true` if successful</returns>
public static bool ATDataIncreaseLength(Foundation.ATDataUnsafe data, ulong extraLength, byte fillWith)
{
var _arg0 = ReferenceEquals(data, null) ? IntPtr.Zero : data._Instance;
var _ret = _Internal.ATDataIncreaseLength(_arg0, extraLength, fillWith);
return(_ret);
}
/// <summary>Determine if a data object owns its storage buffer</summary>
/// <param name="data">The data object</param>
/// <returns>`true` if the data object does own its storage</returns>
public static bool ATDataOwnsStorage(Foundation.ATDataUnsafe data)
{
var _arg0 = ReferenceEquals(data, null) ? IntPtr.Zero : data._Instance;
var _ret = _Internal.ATDataOwnsStorage(_arg0);
return(_ret);
}
/// <summary>Append bytes to the data</summary>
/// <param name="data">The data object</param>
/// <param name="bytesToAppend">A pointer to bytes to append</param>
/// <param name="length">The length of the bytes to append</param>
/// <returns>`true` if appending was successful</returns>
/// <remarks>The bytes will be copied into the data object's storage buffer</remarks>
public static bool ATDataAppendBytes(Foundation.ATDataUnsafe data, IntPtr bytesToAppend, ulong length)
{
var _arg0 = ReferenceEquals(data, null) ? IntPtr.Zero : data._Instance;
var _ret = _Internal.ATDataAppendBytes(_arg0, bytesToAppend, length);
return(_ret);
}
/// <summary>Remove bytes from the data</summary>
/// <param name="data">The data object</param>
/// <param name="length">The length of data to remove</param>
/// <param name="index">The index from which to remove the data</param>
/// <returns>`true` if removal was successful</returns>
/// <remarks>Will not zero out bytes above new length</remarks>
public static bool ATDataRemoveBytes(Foundation.ATDataUnsafe data, ulong length, ulong index)
{
var _arg0 = ReferenceEquals(data, null) ? IntPtr.Zero : data._Instance;
var _ret = _Internal.ATDataRemoveBytes(_arg0, length, index);
return(_ret);
}
public ATDataUnsafe(Foundation.ATDataUnsafe _0)
{
_Instance = Marshal.AllocHGlobal(sizeof(Foundation.ATDataUnsafe._Internal));
_ownsNativeInstance = true;
NativeToManagedMap[_Instance] = this;
*((Foundation.ATDataUnsafe._Internal *)_Instance) = *((Foundation.ATDataUnsafe._Internal *)_0._Instance);
}
/// <summary>Adopt a given storage buffer as the object's storage buffer</summary>
/// <param name="data">The data object</param>
/// <param name="storageToAdopt">The storage buffer to adopt</param>
/// <param name="capacity">The capacity of the storage buffer</param>
/// <param name="length">The length of data currently stored in the buffer</param>
/// <param name="shouldOwnStorage">If this data object should assume ownership of the storage buffer</param>
/// <returns>`true` if the storage was adopted successfully</returns>
public static bool ATDataAdoptStorage(Foundation.ATDataUnsafe data, IntPtr storageToAdopt, ulong capacity, ulong length, bool shouldOwnStorage)
{
var _arg0 = ReferenceEquals(data, null) ? IntPtr.Zero : data._Instance;
var _ret = _Internal.ATDataAdoptStorage(_arg0, storageToAdopt, capacity, length, shouldOwnStorage);
return(_ret);
}
/// <summary>Parse data into multiple config objects</summary>
/// <param name="data">The data to parse</param>
/// <param name="configStorage">An array of pointers to config objects, already initiated.</param>
/// <param name="portsAvailable">The ports that are currently available. If a port is not available, no data will be parsed for that port and the config object's `available` property will be set to false</param>
/// <returns>`true` if successful, otherwise `false`.</returns>
public static bool ATAnalogInputConfigParseMultiple(Foundation.ATDataUnsafe data, DeviceConfiguration.ATAnalogInputConfigUnsafe[] configStorage, byte portsAvailable)
{
var _arg0 = ReferenceEquals(data, null) ? IntPtr.Zero : data._Instance;
if (configStorage == null || configStorage.Length != 8)
{
throw new ArgumentOutOfRangeException("configStorage", "The dimensions of the provided array don't match the required size.");
}
IntPtr[] _configStorage;
if (ReferenceEquals(configStorage, null))
{
_configStorage = null;
}
else
{
_configStorage = new IntPtr[configStorage.Length];
for (int i = 0; i < _configStorage.Length; i++)
{
var _element = configStorage[i];
_configStorage[i] = ReferenceEquals(_element, null) ? IntPtr.Zero : _element._Instance;
}
}
var _arg1 = _configStorage;
var _ret = _Internal.ATAnalogInputConfigParseMultiple(_arg0, _arg1, portsAvailable);
return(_ret);
}
/// <summary>Resize a data object's length</summary>
/// <param name="data">The data object</param>
/// <param name="newLength">The new length of the data object. If longer than current capacity, buffer resize will be attempted.</param>
/// <returns>`true` if resize was successful. If not the buffer and data length will remain the same size</returns>
/// <remarks>After resizing, the buffer pointer may change. If the data object does not own the data buffer then it cannot resize it so this will fail.</remarks>
public static bool ATDataResize(Foundation.ATDataUnsafe data, ulong newLength)
{
var _arg0 = ReferenceEquals(data, null) ? IntPtr.Zero : data._Instance;
var _ret = _Internal.ATDataResize(_arg0, newLength);
return(_ret);
}
/// <summary>Copy a data object into a new destination object</summary>
/// <param name="destination">The destination object</param>
/// <param name="source">The source object</param>
/// <returns>`true` if the copy was successful</returns>
/// <remarks>Will also copy the data buffer to the destination's buffer (as much as will fit in the destination capacity without resizing destination)</remarks>
public static bool ATDataCopy(Foundation.ATDataUnsafe destination, Foundation.ATDataUnsafe source)
{
var _arg0 = ReferenceEquals(destination, null) ? IntPtr.Zero : destination._Instance;
var _arg1 = ReferenceEquals(source, null) ? IntPtr.Zero : source._Instance;
var _ret = _Internal.ATDataCopy(_arg0, _arg1);
return(_ret);
}
/// <summary>Determine if two data objects are equal</summary>
/// <param name="data1">The first data object</param>
/// <param name="data2">The second data object</param>
/// <returns>`true` if the data objects are equal (the bytes in the data buffer are the same and the length is the same)</returns>
public static bool ATDataIsEqual(Foundation.ATDataUnsafe data1, Foundation.ATDataUnsafe data2)
{
var _arg0 = ReferenceEquals(data1, null) ? IntPtr.Zero : data1._Instance;
var _arg1 = ReferenceEquals(data2, null) ? IntPtr.Zero : data2._Instance;
var _ret = _Internal.ATDataIsEqual(_arg0, _arg1);
return(_ret);
}
/// <summary>Adopt a range of data into the subData object without copying.</summary>
/// <param name="data">The data object</param>
/// <param name="subData">The subdata object to adopt the buffer into</param>
/// <param name="offset">The offset to start copying from</param>
/// <param name="length">The length of data to copy</param>
/// <returns>`true` if adoption was successful</returns>
/// <remarks>The subData object will simply hold a pointer to the original `data` object's buffer at `offset`.</remarks>
public static bool ATDataSubdataNoCopyWithRange(Foundation.ATDataUnsafe data, Foundation.ATDataUnsafe subData, ulong offset, ulong length)
{
var _arg0 = ReferenceEquals(data, null) ? IntPtr.Zero : data._Instance;
var _arg1 = ReferenceEquals(subData, null) ? IntPtr.Zero : subData._Instance;
var _ret = _Internal.ATDataSubdataNoCopyWithRange(_arg0, _arg1, offset, length);
return(_ret);
}
/// <summary>Initialize a new data object with given bytes by storing a pointer to the data without copying it</summary>
/// <param name="data">The object to initialize. Can be `NULL` so the result from `ATDataNew` can be passed directly, in which case it will simply return `NULL`</param>
/// <param name="existingData">A pointer to some existing data to use in the new data object</param>
/// <param name="length">The length of the existing data</param>
/// <param name="capacity">The capacity of the buffer pointed to. This can be larger or the same as the length but not smaller.</param>
/// <returns>The initialized data object with the existing data copied in or `NULL` if initialization failed</returns>
public static Foundation.ATDataUnsafe ATDataInitWithBytesNoCopy(Foundation.ATDataUnsafe data, IntPtr existingData, ulong length, ulong capacity)
{
var _arg0 = ReferenceEquals(data, null) ? IntPtr.Zero : data._Instance;
var _ret = _Internal.ATDataInitWithBytesNoCopy(_arg0, existingData, length, capacity);
Foundation.ATDataUnsafe _result0;
if (_ret == IntPtr.Zero)
{
_result0 = null;
}
else if (Foundation.ATDataUnsafe.NativeToManagedMap.ContainsKey(_ret))
{
_result0 = (Foundation.ATDataUnsafe)Foundation.ATDataUnsafe.NativeToManagedMap[_ret];
}
else
{
_result0 = Foundation.ATDataUnsafe._CreateInstance(_ret);
}
return(_result0);
}
/// <summary>Initialize a new data object with empty bytes</summary>
/// <param name="data">The object to initialize. Can be `NULL` so the result from `ATDataNew` can be passed directly, in which case it will simply return `NULL`</param>
/// <returns>The initialized object or `NULL` if initialization failed</returns>
public static Foundation.ATDataUnsafe ATDataInit(Foundation.ATDataUnsafe data)
{
var _arg0 = ReferenceEquals(data, null) ? IntPtr.Zero : data._Instance;
var _ret = _Internal.ATDataInit(_arg0);
Foundation.ATDataUnsafe _result0;
if (_ret == IntPtr.Zero)
{
_result0 = null;
}
else if (Foundation.ATDataUnsafe.NativeToManagedMap.ContainsKey(_ret))
{
_result0 = (Foundation.ATDataUnsafe)Foundation.ATDataUnsafe.NativeToManagedMap[_ret];
}
else
{
_result0 = Foundation.ATDataUnsafe._CreateInstance(_ret);
}
return(_result0);
}
/// <summary>Create a new data object, for use in subclasses</summary>
/// <param name="optionalStorage">Optionally, a pointer to a struct or memory where the object can be stored</param>
/// <param name="type">The type of object we are creating</param>
/// <returns>A new object subclassing `ATData` of the type and size specified</returns>
public static Foundation.ATDataUnsafe ATDataSubclassNew(Foundation.ATDataUnsafe optionalStorage, Foundation.ATObjectType type)
{
var _arg0 = ReferenceEquals(optionalStorage, null) ? IntPtr.Zero : optionalStorage._Instance;
var _ret = _Internal.ATDataSubclassNew(_arg0, type);
Foundation.ATDataUnsafe _result0;
if (_ret == IntPtr.Zero)
{
_result0 = null;
}
else if (Foundation.ATDataUnsafe.NativeToManagedMap.ContainsKey(_ret))
{
_result0 = (Foundation.ATDataUnsafe)Foundation.ATDataUnsafe.NativeToManagedMap[_ret];
}
else
{
_result0 = Foundation.ATDataUnsafe._CreateInstance(_ret);
}
return(_result0);
}
/// <summary>Get data for multiple configs</summary>
/// <param name="optionalDataToFill">An optional data object to fill with the generated data</param>
/// <param name="configStorage">An array of pointers to config objects, already initiated.</param>
/// <param name="portsAvailable">The ports that are currently available. If a port is not available, no data will be generated for that port</param>
/// <param name="includeLimits">If `true`, will include the limit values</param>
/// <returns>The generated data. On failure, returns `NULL`. Otherwise, if `optionalDataToFill` is NULL, returns a data object owned by caller with retain count 1, otherwise returns `optionalDataToFill`</returns>
public static Foundation.ATDataUnsafe ATAnalogInputConfigGetDataMultiple(Foundation.ATDataUnsafe optionalDataToFill, DeviceConfiguration.ATAnalogInputConfigUnsafe[] configStorage, byte portsAvailable, bool includeLimits)
{
var _arg0 = ReferenceEquals(optionalDataToFill, null) ? IntPtr.Zero : optionalDataToFill._Instance;
if (configStorage == null || configStorage.Length != 8)
{
throw new ArgumentOutOfRangeException("configStorage", "The dimensions of the provided array don't match the required size.");
}
IntPtr[] _configStorage;
if (ReferenceEquals(configStorage, null))
{
_configStorage = null;
}
else
{
_configStorage = new IntPtr[configStorage.Length];
for (int i = 0; i < _configStorage.Length; i++)
{
var _element = configStorage[i];
_configStorage[i] = ReferenceEquals(_element, null) ? IntPtr.Zero : _element._Instance;
}
}
var _arg1 = _configStorage;
var _ret = _Internal.ATAnalogInputConfigGetDataMultiple(_arg0, _arg1, portsAvailable, includeLimits);
Foundation.ATDataUnsafe _result0;
if (_ret == IntPtr.Zero)
{
_result0 = null;
}
else if (Foundation.ATDataUnsafe.NativeToManagedMap.ContainsKey(_ret))
{
_result0 = (Foundation.ATDataUnsafe)Foundation.ATDataUnsafe.NativeToManagedMap[_ret];
}
else
{
_result0 = Foundation.ATDataUnsafe._CreateInstance(_ret);
}
return(_result0);
}
/// <summary>Parse data into multiple config objects</summary>
/// <param name="inputConfigManager">The input config manager</param>
/// <param name="data">The data to parse</param>
/// <returns>`true` if successful, otherwise `false`.</returns>
public static bool ATAnalogInputConfigManagerParseMultiple(DeviceConfiguration.ATAnalogInputConfigManagerUnsafe inputConfigManager, Foundation.ATDataUnsafe data)
{
var _arg0 = ReferenceEquals(inputConfigManager, null) ? IntPtr.Zero : inputConfigManager._Instance;
var _arg1 = ReferenceEquals(data, null) ? IntPtr.Zero : data._Instance;
var _ret = _Internal.ATAnalogInputConfigManagerParseMultiple(_arg0, _arg1);
return(_ret);
}
/// <summary>Get the analog analog input config data</summary>
/// <param name="inputConfig">The analog input config</param>
/// <param name="optionalDataToFill">An optional data object to fill with the generated data</param>
/// <returns>The generated data. On failure, returns `NULL`. Otherwise, if `optionalDataToFill` is NULL, returns a data object owned by the analog input config object, otherwise returns `optionalDataToFill`</returns>
public static Foundation.ATDataUnsafe ATAnalogInputConfigGetData(DeviceConfiguration.ATAnalogInputConfigUnsafe inputConfig, Foundation.ATDataUnsafe optionalDataToFill, bool includeLimits)
{
var _arg0 = ReferenceEquals(inputConfig, null) ? IntPtr.Zero : inputConfig._Instance;
var _arg1 = ReferenceEquals(optionalDataToFill, null) ? IntPtr.Zero : optionalDataToFill._Instance;
var _ret = _Internal.ATAnalogInputConfigGetData(_arg0, _arg1, includeLimits);
Foundation.ATDataUnsafe _result0;
if (_ret == IntPtr.Zero)
{
_result0 = null;
}
else if (Foundation.ATDataUnsafe.NativeToManagedMap.ContainsKey(_ret))
{
_result0 = (Foundation.ATDataUnsafe)Foundation.ATDataUnsafe.NativeToManagedMap[_ret];
}
else
{
_result0 = Foundation.ATDataUnsafe._CreateInstance(_ret);
}
return(_result0);
}
/// <summary>Parse data into a analog input config object from its binary representation as received from an AirTurn</summary>
/// <param name="inputConfig">The analog input config object</param>
/// <param name="data">The data</param>
/// <param name="lengthParsed">The length of the data</param>
/// <returns>The initialized object or `NULL` if initialization failed</returns>
public static bool ATAnalogInputConfigParseData(DeviceConfiguration.ATAnalogInputConfigUnsafe inputConfig, Foundation.ATDataUnsafe data, ref ulong lengthParsed)
{
var _arg0 = ReferenceEquals(inputConfig, null) ? IntPtr.Zero : inputConfig._Instance;
var _arg1 = ReferenceEquals(data, null) ? IntPtr.Zero : data._Instance;
fixed(ulong *_lengthParsed2 = &lengthParsed)
{
var _arg2 = _lengthParsed2;
var _ret = _Internal.ATAnalogInputConfigParseData(_arg0, _arg1, _arg2);
return(_ret);
}
}
/// <summary>Initialize a new analog input config object from its binary representation as received from an AirTurn</summary>
/// <param name="inputConfig">The analog input config object</param>
/// <param name="data">The data</param>
/// <param name="lengthParsed">The length of the data</param>
/// <returns>The initialized object or `NULL` if initialization failed</returns>
public static DeviceConfiguration.ATAnalogInputConfigUnsafe ATAnalogInputConfigInitWithData(DeviceConfiguration.ATAnalogInputConfigUnsafe inputConfig, Foundation.ATDataUnsafe data, ref ulong lengthParsed)
{
var _arg0 = ReferenceEquals(inputConfig, null) ? IntPtr.Zero : inputConfig._Instance;
var _arg1 = ReferenceEquals(data, null) ? IntPtr.Zero : data._Instance;
fixed(ulong *_lengthParsed2 = &lengthParsed)
{
var _arg2 = _lengthParsed2;
var _ret = _Internal.ATAnalogInputConfigInitWithData(_arg0, _arg1, _arg2);
DeviceConfiguration.ATAnalogInputConfigUnsafe _result0;
if (_ret == IntPtr.Zero)
{
_result0 = null;
}
else if (DeviceConfiguration.ATAnalogInputConfigUnsafe.NativeToManagedMap.ContainsKey(_ret))
{
_result0 = (DeviceConfiguration.ATAnalogInputConfigUnsafe)DeviceConfiguration.ATAnalogInputConfigUnsafe.NativeToManagedMap[_ret];
}
else
{
_result0 = DeviceConfiguration.ATAnalogInputConfigUnsafe._CreateInstance(_ret);
}
return(_result0);
}
}
/// <summary>Copy bytes from the data object at a given start offset into a given buffer</summary>
/// <param name="data">The data object</param>
/// <param name="bytes">The buffer to copy into</param>
/// <param name="offset">The offset in the data object to copy from</param>
/// <param name="maxLength">The maximum length of data to copy</param>
public static void ATDataGetBytesAtOffset(Foundation.ATDataUnsafe data, IntPtr bytes, ulong offset, ulong maxLength)
{
var _arg0 = ReferenceEquals(data, null) ? IntPtr.Zero : data._Instance;
_Internal.ATDataGetBytesAtOffset(_arg0, bytes, offset, maxLength);
}
/// <summary>Parse data into a analog input config manager object from its binary representation as received from an AirTurn/storage</summary>
/// <param name="inputConfigManager">The analog input config manager object</param>
/// <param name="port">The port to parse data for</param>
/// <param name="data">The data</param>
/// <param name="lengthParsed">The length of the data</param>
/// <returns>The initialized object or `NULL` if initialization failed</returns>
public static bool ATAnalogInputConfigManagerParseData(DeviceConfiguration.ATAnalogInputConfigManagerUnsafe inputConfigManager, DeviceTypes.ATPortUnsafe port, Foundation.ATDataUnsafe data, ref ulong lengthParsed)
{
var _arg0 = ReferenceEquals(inputConfigManager, null) ? IntPtr.Zero : inputConfigManager._Instance;
var _arg2 = ReferenceEquals(data, null) ? IntPtr.Zero : data._Instance;
fixed(ulong *_lengthParsed3 = &lengthParsed)
{
var _arg3 = _lengthParsed3;
var _ret = _Internal.ATAnalogInputConfigManagerParseData(_arg0, port, _arg2, _arg3);
return(_ret);
}
}
