/// <summary>Append a constant string</summary>
/// <param name="string">The string object</param>
/// <param name="stringToAppend">The string to append</param>
/// <returns>`true` if successful</returns>
/// <remarks>Will determine the length of the string by finding the null terminating character</remarks>
public static bool ATStringAppendString(Foundation.ATStringUnsafe @string, string stringToAppend)
{
var _arg0 = ReferenceEquals(@string, null) ? IntPtr.Zero : @string._Instance;
var _ret = _Internal.ATStringAppendString(_arg0, stringToAppend);
return(_ret);
}
/// <summary>Get a debug description for an object</summary>
/// <param name="object">The object</param>
/// <param name="string">The string to populate with a description</param>
/// <returns>`true` if the object could be described successfully</returns>
public static bool ATGetDebugDescription(IntPtr @object, Foundation.ATStringUnsafe @string)
{
var _arg1 = ReferenceEquals(@string, null) ? IntPtr.Zero : @string._Instance;
var _ret = _Internal.ATGetDebugDescription(@object, _arg1);
return(_ret);
}
/// <summary>Resize the string to fit its length</summary>
/// <param name="string">The string object</param>
/// <returns>`true` if successful</returns>
public static bool ATStringResizeMaxLengthToFit(Foundation.ATStringUnsafe @string)
{
var _arg0 = ReferenceEquals(@string, null) ? IntPtr.Zero : @string._Instance;
var _ret = _Internal.ATStringResizeMaxLengthToFit(_arg0);
return(_ret);
}
/// <summary>Resize a string length</summary>
/// <param name="string">The string object</param>
/// <param name="newLength">The new length. If greater than current capacity, the string buffer will be resized if possible</param>
/// <returns>`true` if successful, or false if string buffer could not be resized when required</returns>
public static bool ATStringResize(Foundation.ATStringUnsafe @string, ulong newLength)
{
var _arg0 = ReferenceEquals(@string, null) ? IntPtr.Zero : @string._Instance;
var _ret = _Internal.ATStringResize(_arg0, newLength);
return(_ret);
}
public ATStringUnsafe(Foundation.ATStringUnsafe _0)
{
_Instance = Marshal.AllocHGlobal(sizeof(Foundation.ATStringUnsafe._Internal));
_ownsNativeInstance = true;
NativeToManagedMap[_Instance] = this;
*((Foundation.ATStringUnsafe._Internal *)_Instance) = *((Foundation.ATStringUnsafe._Internal *)_0._Instance);
}
/// <summary>Determine if two string objects are equal</summary>
/// <param name="string1">The first string</param>
/// <param name="string2">The second string</param>
/// <returns>`true` if the strings are equal</returns>
public static bool ATStringIsEqual(Foundation.ATStringUnsafe string1, Foundation.ATStringUnsafe string2)
{
var _arg0 = ReferenceEquals(string1, null) ? IntPtr.Zero : string1._Instance;
var _arg1 = ReferenceEquals(string2, null) ? IntPtr.Zero : string2._Instance;
var _ret = _Internal.ATStringIsEqual(_arg0, _arg1);
return(_ret);
}
/// <summary>Copy a string object</summary>
/// <param name="destination">The destination string object to copy into</param>
/// <param name="source">The source string object</param>
/// <returns>`true` if successful</returns>
public static bool ATStringCopy(Foundation.ATStringUnsafe destination, Foundation.ATStringUnsafe source)
{
var _arg0 = ReferenceEquals(destination, null) ? IntPtr.Zero : destination._Instance;
var _arg1 = ReferenceEquals(source, null) ? IntPtr.Zero : source._Instance;
var _ret = _Internal.ATStringCopy(_arg0, _arg1);
return(_ret);
}
/// <summary>Initialize a string object from an existing string using the existing buffer without copying</summary>
/// <param name="string">The object to initialize. Can be `NULL` so the result from `ATStringNew` can be passed directly, in which case it will simply return `NULL`</param>
/// <param name="existingString">The existing string buffer</param>
/// <param name="length">The existing string length excluding terminating null</param>
/// <param name="capacity">The maximum capacity of the existing string buffer</param>
/// <returns>The initialized object or `NULL` if initialization failed</returns>
public static Foundation.ATStringUnsafe ATStringInitWithStringBufferNoCopy(Foundation.ATStringUnsafe @string, sbyte *existingString, ulong length, ulong capacity)
{
var _arg0 = ReferenceEquals(@string, null) ? IntPtr.Zero : @string._Instance;
var _ret = _Internal.ATStringInitWithStringBufferNoCopy(_arg0, existingString, length, capacity);
Foundation.ATStringUnsafe _result0;
if (_ret == IntPtr.Zero)
{
_result0 = null;
}
else if (Foundation.ATStringUnsafe.NativeToManagedMap.ContainsKey(_ret))
{
_result0 = (Foundation.ATStringUnsafe)Foundation.ATStringUnsafe.NativeToManagedMap[_ret];
}
else
{
_result0 = Foundation.ATStringUnsafe._CreateInstance(_ret);
}
return(_result0);
}
/// <summary>Initialize a string object</summary>
/// <param name="string">The object to initialize. Can be `NULL` so the result from `ATStringNew` can be passed directly, in which case it will simply return `NULL`</param>
/// <param name="maxLength">The maximum length of the string</param>
/// <returns>The initialized object or `NULL` if initialization failed</returns>
public static Foundation.ATStringUnsafe ATStringInit(Foundation.ATStringUnsafe @string, ulong maxLength)
{
var _arg0 = ReferenceEquals(@string, null) ? IntPtr.Zero : @string._Instance;
var _ret = _Internal.ATStringInit(_arg0, maxLength);
Foundation.ATStringUnsafe _result0;
if (_ret == IntPtr.Zero)
{
_result0 = null;
}
else if (Foundation.ATStringUnsafe.NativeToManagedMap.ContainsKey(_ret))
{
_result0 = (Foundation.ATStringUnsafe)Foundation.ATStringUnsafe.NativeToManagedMap[_ret];
}
else
{
_result0 = Foundation.ATStringUnsafe._CreateInstance(_ret);
}
return(_result0);
}
/// <summary>Create a new string</summary>
/// <param name="optionalStorage">Optionally, a pointer to a struct or memory where the object can be stored</param>
/// <returns>A pointer to the new object. `NULL` if allocation could not be completed</returns>
public static Foundation.ATStringUnsafe ATStringNew(Foundation.ATStringUnsafe optionalStorage)
{
var _arg0 = ReferenceEquals(optionalStorage, null) ? IntPtr.Zero : optionalStorage._Instance;
var _ret = _Internal.ATStringNew(_arg0);
Foundation.ATStringUnsafe _result0;
if (_ret == IntPtr.Zero)
{
_result0 = null;
}
else if (Foundation.ATStringUnsafe.NativeToManagedMap.ContainsKey(_ret))
{
_result0 = (Foundation.ATStringUnsafe)Foundation.ATStringUnsafe.NativeToManagedMap[_ret];
}
else
{
_result0 = Foundation.ATStringUnsafe._CreateInstance(_ret);
}
return(_result0);
}
/// <summary>Get a description for a digital port state value</summary>
/// <param name="string">The string to append the description to</param>
/// <param name="ports">The digital port state value</param>
public static void ATPortsDescription(Foundation.ATStringUnsafe @string, byte ports)
{
var _arg0 = ReferenceEquals(@string, null) ? IntPtr.Zero : @string._Instance;
_Internal.ATPortsDescription(_arg0, ports);
}
/// <summary>Reset the string to be empty. Does not reduce the string capacity</summary>
/// <param name="string">The string object</param>
public static void ATStringResetToEmpty(Foundation.ATStringUnsafe @string)
{
var _arg0 = ReferenceEquals(@string, null) ? IntPtr.Zero : @string._Instance;
_Internal.ATStringResetToEmpty(_arg0);
}
