/// <inheritdoc />
/// <summary>
/// Message event args
/// </summary>
/// <param name="message">Message object</param>
/// <param name="correlationId">Correlation Id</param>
public RawMessageEventArgs(MultiArray <byte> message, Guid correlationId)
{
CorrelationId = correlationId;
Message = message;
}
public Task <MultiArray <byte> > CompressAsync(MultiArray <byte> source) => Task.FromResult(_implementation.Compress(source));
public T Deserialize <T>(MultiArray <byte> value) => (T)((ISerializer)this).Deserialize(value, typeof(T));
/// <summary> /// Deserialize an object using the MsgPack serializer /// </summary> /// <param name="value">TBinary serialized object</param> /// <param name="type">Object type</param> /// <returns>Object instance</returns> public static object DeserializeFromMsgPack(this MultiArray <byte> value, Type type) => Serializer.Deserialize(value, type);
protected override void Enabled()
{
UserChat = new MultiArray<String, WebMessage>();
CredentialList = Authentication.GetCredentials();
WebSessions = new Dictionary<String, Identity>();
KickList = new List<KeyValuePair<String, Identity>>();
WebSender = new WebSender(this);
//Hook(HookPoints.PlayerChat, OnPlayerChat);
//Hook(HookPoints.PlayerEnteredGame, OnPlayerJoin);
//Hook(HookPoints.PlayerLeftGame, OnPlayerDisconnect);
//Hook(HookPoints.ConsoleMessageReceived, OnConsoleMessageReceived);
AddCommand("webserver")
.WithAccessLevel(AccessLevel.CONSOLE)
.WithDescription("Manage the WebKit Http Server.")
.WithHelpText("Usage: webserver stop:start:restart")
.Calls(Server);
AddCommand("webconnection")
.WithAccessLevel(AccessLevel.CONSOLE)
.WithDescription("Manage Http connections to WebKit.")
.WithHelpText("Usage: connection view")
.WithHelpText(" connection kick <id>")
.Calls(Connection);
AddCommand("webusers")
.WithAccessLevel(AccessLevel.CONSOLE)
.WithDescription("Manage Htp users.")
.WithHelpText("Usage: webusers add <user> <pass>")
.WithHelpText(" webusers remove <user>")
.WithHelpText(" webusers reloadconfig")
.Calls(Users);
WebServer = new WebServer(Properties.IPAddress, Properties.Port, this);
WebServer.StartServer();
ProgramLog.Plugin.Log("WebKit for TDSM #{0} enabled.", base.TDSMBuild);
}
///############################################################
/// <summary>
/// Initializes the class.
/// </summary>
/// <param name="oTable">MultiArray representing the table metadata to render.<para/>NOTE: Column definitions can be from more then one table.</param>
/// <param name="sIDColumn">String representing the name of the primary key column (this column will not be included in the generated SQL statements).<para/>NOTE: Pass in a null-string if there is no ID column.</param>
///############################################################
/// <LastUpdated>December 11, 2009</LastUpdated>
private void Initilize(MultiArray oTable, string sIDColumn)
{
Inputs.AdditionalData oAdditionalData = new Inputs.AdditionalData();
string sPicklistName;
string sColumnName;
int iIDColumnLen;
int i;
Inputs.enumSaveTypes eSaveType;
//#### Init the global vars
g_oGet = new DBMS.GetValue(this);
ga_sInputAliases = null;
g_iColumnCount = 0;
//#### If the caller passed in a oTable with data
if (oTable != null && oTable.RowCount > 0)
{
//#### Reset g_iColumnCount, dimension ga_sInputAliases and determine sIDColumn's .Length
g_iColumnCount = oTable.RowCount;
ga_sInputAliases = new string[g_iColumnCount];
iIDColumnLen = sIDColumn.Length;
//#### Traverse the oTable's .Rows (each of which represent a column within the referenced sTableName)
for (i = 0; i < g_iColumnCount; i++)
{
//#### Collect the current sColumnName, setting it into the ga_sInputAliases as we go (as we use the sColumnName as the sInputAlias below)
sColumnName = oTable.Value(i, "Column_Name");
ga_sInputAliases[i] = sColumnName;
//#### If the current sColumnName matches the passed sIDColumn (checking their .Lengths first as that is a far faster comparsion)
if (iIDColumnLen == sColumnName.Length && sIDColumn == sColumnName)
{
//#### Set the current sColumnName/sIDColumn's eSaveType as .cnID
eSaveType = Web.Inputs.enumSaveTypes.cnID;
}
//#### Else this is a non-.cnID column definition
else
{
//#### If the current column Is_Nullable, set it's eSaveType as .cnInsertNull
if (Data.Tools.MakeBoolean(oTable.Value(i, "Is_Nullable"), false))
{
eSaveType = Web.Inputs.enumSaveTypes.cnInsertNull;
}
//#### Else the current column Is_(not)Nullable, so set it's eSaveType as .cnRequired
else
{
eSaveType = Web.Inputs.enumSaveTypes.cnRequired;
}
}
//#### Collect the current RelatedPicklist sPicklistName
sPicklistName = Data.Tools.MakeString(oTable.Value(i, "RelatedPicklist"), "");
//#### If a sPicklistName was collected above, set it into the oAdditionalData
if (sPicklistName.Length > 0)
{
oAdditionalData.Picklist_Name = sPicklistName;
}
//#### Else no sPicklistName was found, so ensure that the related key in oAdditionalData is blank
else
{
oAdditionalData.Picklist_Name = null;
}
//#### .Add the above determined input
InputCollection.Add(sColumnName, oTable.Value(i, "Table_Name"), sColumnName, eSaveType, MetaData.enumValueTypes.cnSingleValue, oAdditionalData);
}
}
//#### Else the passed a oTable that was empty, so raise the error
else
{
//!
}
}
public RegisteredServiceContainer(RegisteredService service, ISerializer serializer, MultiArray <byte> dataToSend)
{
Service = service;
Serializer = serializer;
DataToSend = dataToSend;
}
public static string GetHashSHA384(this MultiArray <byte> bytes) => Hash.Get(bytes);
///############################################################
/// <summary>
/// Maps data between the provided objects.
/// </summary>
/// <param name="oFrom">Object to be used as the data source.</param>
/// <param name="oTo">Object to be used as the data destination.</param>
/// <param name="iRowIndex">Integer representing the row index to use within the data source.</param>
/// <returns>Boolean value representing if all of the readable properties within the provided <paramref name="oFrom"/> were successfully mapped into <paramref name="oTo"/>.</returns>
///############################################################
/// <LastUpdated>February 15, 2010</LastUpdated>
public static bool Map(IList <Controls.Input> oFrom, MultiArray oTo, int iRowIndex)
{
//#### Pass the call into .DoMap, signaling that it is to .Populate(the)Controls
return(DoMap(oTo, oFrom, iRowIndex, enumDirection.PopulateBusinessObject));
}
/// <summary> /// Deserialize json value to an object instance /// </summary> /// <typeparam name="T">Object type</typeparam> /// <param name="value">Serialized json value</param> /// <returns>Object instance</returns> public static T DeserializeFromUtf8JsonBytes <T>(this MultiArray <byte> value) => Serializer.Deserialize <T>(value);
///############################################################
/// <summary>
/// Maps data between the provided objects.
/// </summary>
/// <param name="oFrom">Object to be used as the data source.</param>
/// <param name="oTo">Object to be used as the data destination.</param>
/// <param name="iRowIndex">Integer representing the row index to use within the data source.</param>
/// <returns>Boolean value representing if all of the readable properties within the provided <paramref name="oFrom"/> were successfully mapped into <paramref name="oTo"/>.</returns>
///############################################################
/// <LastUpdated>February 15, 2010</LastUpdated>
public static bool Map(MultiArray oFrom, IList <Controls.Input> oTo, int iRowIndex)
{
//#### Pass the call into .DoMap, signaling that it is to .Populate(the)Controls
return(DoMap(oFrom, oTo, iRowIndex, enumDirection.PopulateContols));
}
protected abstract Task <int> OnSendAsync(MultiArray <byte> message, RawRequestReceivedEventArgs e);
public void Setup()
{
Core.InitDefaults();
var sTest = new STest
{
FirstName = "Daniel",
LastName = "Redondo",
Age = 35,
value = 166
};
_data = new List <STest>
{
sTest, sTest, sTest, sTest, sTest, sTest,
sTest, sTest, sTest, sTest, sTest, sTest,
new STest {
FirstName = "Person", LastName = "Person" + "." + 0, Age = 1, Brother = sTest
},
new STest {
FirstName = "Person", LastName = "Person" + "." + 1, Age = 2, Brother = sTest
},
new STest {
FirstName = "Person", LastName = "Person" + "." + 2, Age = 3, Brother = sTest
},
new STest {
FirstName = "Person", LastName = "Person" + "." + 3, Age = 4, Brother = sTest
},
new STest {
FirstName = "Person", LastName = "Person" + "." + 4, Age = 5, Brother = sTest
},
new STest {
FirstName = "Person", LastName = "Person" + "." + 5, Age = 6, Brother = sTest
},
new STest {
FirstName = "Person", LastName = "Person" + "." + 6, Age = 7, Brother = sTest
},
new STest {
FirstName = "Person", LastName = "Person" + "." + 7, Age = 8, Brother = sTest
},
new STest {
FirstName = "Person", LastName = "Person" + "." + 8, Age = 9, Brother = sTest
},
new STest {
FirstName = "Person", LastName = "Person" + "." + 9, Age = 10, Brother = sTest
},
new STest {
FirstName = "Person", LastName = "Person" + "." + 10, Age = 11
},
new STest {
FirstName = "Person", LastName = "Person" + "." + 11, Age = 12
},
new STest {
FirstName = "Person", LastName = "Person" + "." + 12, Age = 13
},
new STest {
FirstName = "Person", LastName = "Person" + "." + 13, Age = 14
},
new STest {
FirstName = "Person", LastName = "Person" + "." + 14, Age = 15
},
new STest {
FirstName = "Person", LastName = "Person" + "." + 15, Age = 16
},
new STest {
FirstName = "Person", LastName = "Person" + "." + 16, Age = 17
},
new STest {
FirstName = "Person", LastName = "Person" + "." + 17, Age = 18
},
new STest {
FirstName = "Person", LastName = "Person" + "." + 18, Age = 19
},
};
_jsonSerializer = new JsonTextSerializer();
_binData = _jsonSerializer.Serialize(_data);
_jsonSerializerStream = new MemoryStream();
_jsonSerializer.Serialize(_data, _jsonSerializerStream);
_xmlSerializer = new XmlTextSerializer();
_binData = _xmlSerializer.Serialize(_data);
_xmlSerializerStream = new MemoryStream();
_xmlSerializer.Serialize(_data, _xmlSerializerStream);
_binSerializer = new BinaryFormatterSerializer();
_binData = _binSerializer.Serialize(_data);
_binSerializerStream = new MemoryStream();
_binSerializer.Serialize(_data, _binSerializerStream);
_utf8jsonSerializer = new Utf8JsonTextSerializer();
_binData = _utf8jsonSerializer.Serialize(_data);
_utf8jsonSerializerStream = new MemoryStream();
_utf8jsonSerializer.Serialize(_data, _utf8jsonSerializerStream);
_msgPackSerializer = new MsgPackSerializer();
_binData = _msgPackSerializer.Serialize(_data);
_msgPackSerializerStream = new MemoryStream();
_msgPackSerializer.Serialize(_data, _msgPackSerializerStream);
_nBinary = new NBinarySerializer();
_binData = _nBinary.Serialize(_data);
_nBinaryStream = new MemoryStream();
_nBinary.Serialize(_data, _nBinaryStream);
_rawBinary = new RawBinarySerializer();
_binData = _rawBinary.Serialize(_data);
_rawBinaryStream = new MemoryStream();
_rawBinary.Serialize(_data, _rawBinaryStream);
}
public static async Task <SerializedObject> FromStreamAsync(Stream stream)
{
string dataType = null;
string serializerMimeType = null;
MultiArray <byte> data = MultiArray <byte> .Empty;
#if COMPATIBILITY
var intBuffer = new byte[4];
await stream.ReadExactAsync(intBuffer, 0, 4).ConfigureAwait(false);
var dataTypeByteLength = BitConverter.ToInt32(intBuffer, 0);
if (dataTypeByteLength > -1)
{
var bytes = new byte[dataTypeByteLength];
await stream.ReadExactAsync(bytes, 0, dataTypeByteLength).ConfigureAwait(false);
dataType = Encoding.UTF8.GetString(bytes);
}
await stream.ReadExactAsync(intBuffer, 0, 4).ConfigureAwait(false);
var serializerMimeTypeByteLength = BitConverter.ToInt32(intBuffer, 0);
if (serializerMimeTypeByteLength > -1)
{
var bytes = new byte[serializerMimeTypeByteLength];
await stream.ReadExactAsync(bytes, 0, serializerMimeTypeByteLength).ConfigureAwait(false);
serializerMimeType = Encoding.UTF8.GetString(bytes);
}
await stream.ReadExactAsync(intBuffer, 0, 4).ConfigureAwait(false);
var dataLength = BitConverter.ToInt32(intBuffer, 0);
if (dataLength > -1)
{
const int segmentLength = 8192;
var rows = dataLength / segmentLength;
var pos = dataLength % segmentLength;
if (pos > 0)
{
rows++;
}
else
{
pos = segmentLength;
}
var bytes = SegmentPool.RentContainer();
for (var i = 0; i < rows; i++)
{
var row = SegmentPool.Rent();
await stream.ReadExactAsync(row, 0, i == rows - 1?pos : segmentLength).ConfigureAwait(false);
bytes.Add(row);
}
data = new MultiArray <byte>(bytes, 0, dataLength);
}
#else
var intBuffer = new byte[4];
stream.Fill(intBuffer);
var dataTypeByteLength = BitConverter.ToInt32(intBuffer);
if (dataTypeByteLength > -1)
{
var dBuffer = new byte[dataTypeByteLength];
await stream.FillAsync(dBuffer).ConfigureAwait(false);
dataType = Encoding.UTF8.GetString(dBuffer);
}
stream.Fill(intBuffer);
var serializerMimeTypeByteLength = BitConverter.ToInt32(intBuffer);
if (serializerMimeTypeByteLength > -1)
{
var dBuffer = new byte[serializerMimeTypeByteLength];
await stream.FillAsync(dBuffer).ConfigureAwait(false);
serializerMimeType = Encoding.UTF8.GetString(dBuffer);
}
stream.Fill(intBuffer);
var dataLength = BitConverter.ToInt32(intBuffer);
if (dataLength > -1)
{
var segmentLength = SegmentPool.SegmentLength;
var rows = Math.DivRem(dataLength, segmentLength, out var pos);
if (pos > 0)
{
rows++;
}
else
{
pos = segmentLength;
}
var bytes = SegmentPool.RentContainer();
for (var i = 0; i < rows; i++)
{
var row = SegmentPool.Rent();
await stream.ReadExactAsync(row, 0, i == rows - 1?pos : segmentLength).ConfigureAwait(false);
bytes.Add(row);
}
data = new MultiArray <byte>(bytes, 0, dataLength);
}
#endif
return(new SerializedObject(data, dataType, serializerMimeType));
}
/// <summary> /// Deserialize a binary formatter value to an object instance /// </summary> /// <typeparam name="T">Object type</typeparam> /// <param name="value">Serialized binary formatter value</param> /// <returns>Object instance</returns> public static T DeserializeFromBinFormatter <T>(this MultiArray <byte> value) => Serializer.Deserialize <T>(value);
public static Guid GetHashSHA384Guid(this MultiArray <byte> bytes) => Hash.GetGuid(bytes);
/// <inheritdoc />
/// <summary>
/// On Send message data
/// </summary>
/// <param name="message">Response message instance</param>
/// <param name="e">Event Args</param>
protected override async Task <int> OnSendAsync(MultiArray <byte> message, RawRequestReceivedEventArgs e)
{
var queues = e.ResponseQueues;
var replyTo = e.Metadata["ReplyTo"] ?? string.Empty;
queues.Add(new MQConnection
{
Route = e.Sender.Route,
Parameters = e.Sender.Parameters
});
var senderOptions = Config.ResponseOptions.ServerSenderOptions;
if (senderOptions is null)
{
throw new NullReferenceException("ServerSenderOptions is null.");
}
var header = KafkaQueueRawClient.CreateRawMessageHeader(e.CorrelationId, replyTo);
var body = message.AsArray();
var response = true;
foreach (var queue in e.ResponseQueues)
{
try
{
var producer = _rQueue.GetOrAdd(queue.Route, qRoute =>
{
Core.Log.LibVerbose("New Producer from QueueClient");
if (string.IsNullOrEmpty(qRoute))
{
throw new UriFormatException($"The route for the connection to {qRoute} is null.");
}
var options = new KafkaOptions(new Uri(qRoute));
var router = new BrokerRouter(options);
return(Extensions.InvokeWithRetry(() => new Producer(router), 5000, int.MaxValue).WaitAsync());
});
if (!string.IsNullOrEmpty(replyTo))
{
if (string.IsNullOrEmpty(queue.Name))
{
Core.Log.LibVerbose("Sending {0} bytes to the Queue '{1}/{2}' with CorrelationId={3}", body.Length, queue.Route, replyTo, e.CorrelationId);
await producer.SendMessageAsync(replyTo, new[] { new Message {
Key = header, Value = body
} }).ConfigureAwait(false);
}
else if (queue.Name.StartsWith(replyTo, StringComparison.Ordinal))
{
Core.Log.LibVerbose("Sending {0} bytes to the Queue '{1}/{2}' with CorrelationId={3}", body.Length, queue.Route, queue.Name + "_" + replyTo, e.CorrelationId);
await producer.SendMessageAsync(queue.Name + "_" + replyTo, new[] { new Message {
Key = header, Value = body
} }).ConfigureAwait(false);
}
}
else
{
Core.Log.LibVerbose("Sending {0} bytes to the Queue '{1}/{2}' with CorrelationId={3}", body.Length, queue.Route, queue.Name, e.CorrelationId);
await producer.SendMessageAsync(queue.Name, new[] { new Message {
Key = header, Value = body
} }).ConfigureAwait(false);
}
}
catch (Exception ex)
{
response = false;
Core.Log.Write(ex);
}
}
return(response ? message.Count : -1);
}
public static MultiArray <byte> GetHashSHA384Bytes(this MultiArray <byte> bytes) => Hash.GetBytes(bytes);
///############################################################
/// <summary>
/// Resets the class to its initilized state.
/// </summary>
/// <param name="oInternationalizationData">MultiArray representing the entire, self-referencing Internationalization picklists structure.</param>
/// <exception cref="Cn.CnException">Thrown when the passed <paramref>oInternationalizationData</paramref> is null or contains no <c>Rows</c>.</exception>
/// <exception cref="Cn.CnException">Thrown when the passed <paramref>oInternationalizationData</paramref> does not contain the required column names as defined by <c>Picklists.GetColumnNames</c>.</exception>
/// <exception cref="Cn.CnException">Thrown when the passed <paramref>oInternationalizationData</paramref> contains one or more <c>Rows</c> with a non-numeric value in 'PicklistID'.</exception>
///############################################################
/// <LastUpdated>May 22, 2007</LastUpdated>
public void Reset(MultiArray oInternationalizationData)
{
//#### Pass the call off to .DoReset
DoReset(oInternationalizationData);
}
///############################################################
/// <summary>
/// Initializes the class.
/// </summary>
/// <param name="oSettings">Cn.Web.Settings.Current instance representing the current enviroment.</param>
/// <param name="oTable">MultiArray representing the table metadata to render.<para/>NOTE: Column definitions can be from more then one table.</param>
/// <param name="sIDColumn">String representing the name of the primary key column (this column will not be included in the generated SQL statements).<para/>NOTE: Pass in a null-string if there is no ID column.</param>
///############################################################
/// <LastUpdated>May 30, 2007</LastUpdated>
public TableForm(Settings.Current oSettings, MultiArray oTable, string sIDColumn) : base(oSettings)
{
//#### Pass the call off to .Initilize to do the actual work
Initilize(oTable, sIDColumn);
}
/// <summary> /// Gets the hash bytes from a bytes array /// </summary> /// <param name="value">Bytes array to calculate the hash.</param> /// <returns>Hash bytes array.</returns> public abstract MultiArray <byte> GetHashValue(MultiArray <byte> value);
public static void VerifyAccessorBounds(MemoryAccessor memory, IReadOnlyList <double> min, IReadOnlyList <double> max)
{
Guard.NotNull(memory, nameof(memory));
Guard.NotNull(min, nameof(min));
Guard.NotNull(max, nameof(max));
if (min.Count == 0 && max.Count == 0)
{
return;
}
var dimensions = memory.Attribute.Dimensions.DimCount();
if (min.Count != dimensions)
{
throw new ArgumentException($"min size mismatch; expected {dimensions} but found {min.Count}", nameof(min));
}
if (max.Count != dimensions)
{
throw new ArgumentException($"max size mismatch; expected {dimensions} but found {max.Count}", nameof(max));
}
for (int i = 0; i < min.Count; ++i)
{
// if (_min[i] > _max[i]) result.AddError(this, $"min[{i}] is larger than max[{i}]");
}
var minimum = min.Select(item => (float)item).ToArray();
var maximum = max.Select(item => (float)item).ToArray();
var xinfo = memory.Attribute;
xinfo.Dimensions = DIMENSIONS.SCALAR;
memory = new MemoryAccessor(memory.Data, xinfo);
var array = new MultiArray(memory.Data, memory.Attribute.ByteOffset, memory.Attribute.ItemsCount, memory.Attribute.ByteStride, dimensions, memory.Attribute.Encoding, memory.Attribute.Normalized);
var current = new float[dimensions];
for (int i = 0; i < array.Count; ++i)
{
array.CopyItemTo(i, current);
for (int j = 0; j < current.Length; ++j)
{
var v = current[j];
// if (!v._IsFinite()) result.AddError(this, $"Item[{j}][{i}] is not a finite number: {v}");
var axisMin = minimum[j];
var axisMax = maximum[j];
if (v < axisMin || v > axisMax)
{
throw new ArgumentOutOfRangeException(nameof(memory), $"Value[{i}] is out of bounds. {axisMin} <= {v} <= {axisMax}");
}
// if (v < min || v > max) result.AddError(this, $"Item[{j}][{i}] is out of bounds. {min} <= {v} <= {max}");
}
}
}
public MultiArray <byte> GetBytes(MultiArray <byte> bytes)
{
return(GetHashValue(bytes));
}
/// <summary> /// Deserialize an object using the MsgPack serializer /// </summary> /// <typeparam name="T">Object type</typeparam> /// <param name="value">TBinary serialized object</param> /// <returns>Object instance</returns> public static T DeserializeFromMsgPack <T>(this MultiArray <byte> value) => Serializer.Deserialize <T>(value);
public RawResponseSentEventArgs(string name, MultiArray <byte> message, Guid correlationId)
{
Name = name;
Message = message;
CorrelationId = correlationId;
}
/// <summary> /// Deserialize an object using the NBinary serializer /// </summary> /// <typeparam name="T">Object type</typeparam> /// <param name="value">NBinary serialized object</param> /// <returns>Object instance</returns> public static T DeserializeFromNBinary <T>(this MultiArray <byte> value) => Serializer.Deserialize <T>(value);
public static SerializedObject FromStream(Stream stream)
{
string dataType = null;
string serializerMimeType = null;
MultiArray <byte> data = MultiArray <byte> .Empty;
#if COMPATIBILITY
var intBuffer = new byte[4];
stream.ReadExact(intBuffer, 0, 4);
var dataTypeByteLength = BitConverter.ToInt32(intBuffer, 0);
if (dataTypeByteLength > -1)
{
var bytes = new byte[dataTypeByteLength];
stream.ReadExact(bytes, 0, dataTypeByteLength);
dataType = Encoding.UTF8.GetString(bytes);
}
stream.ReadExact(intBuffer, 0, 4);
var serializerMimeTypeByteLength = BitConverter.ToInt32(intBuffer, 0);
if (serializerMimeTypeByteLength > -1)
{
var bytes = new byte[serializerMimeTypeByteLength];
stream.ReadExact(bytes, 0, serializerMimeTypeByteLength);
serializerMimeType = Encoding.UTF8.GetString(bytes);
}
stream.ReadExact(intBuffer, 0, 4);
var dataLength = BitConverter.ToInt32(intBuffer, 0);
if (dataLength > -1)
{
var segmentLength = SegmentPool.SegmentLength;
var rows = Math.DivRem(dataLength, segmentLength, out var pos);
if (pos > 0)
{
rows++;
}
else
{
pos = segmentLength;
}
var bytes = SegmentPool.RentContainer();
for (var i = 0; i < rows; i++)
{
var row = SegmentPool.Rent();
stream.ReadExact(row, 0, i == rows - 1 ? pos : segmentLength);
bytes.Add(row);
}
data = new MultiArray <byte>(bytes, 0, dataLength);
}
#else
Span <byte> intBuffer = stackalloc byte[4];
stream.Fill(intBuffer);
var dataTypeByteLength = BitConverter.ToInt32(intBuffer);
if (dataTypeByteLength > -1)
{
Span <byte> span = stackalloc byte[dataTypeByteLength];
stream.Fill(span);
dataType = Encoding.UTF8.GetString(span);
}
stream.Fill(intBuffer);
var serializerMimeTypeByteLength = BitConverter.ToInt32(intBuffer);
if (serializerMimeTypeByteLength > -1)
{
Span <byte> span = stackalloc byte[serializerMimeTypeByteLength];
stream.Fill(span);
serializerMimeType = Encoding.UTF8.GetString(span);
}
stream.Fill(intBuffer);
var dataLength = BitConverter.ToInt32(intBuffer);
if (dataLength > -1)
{
var segmentLength = SegmentPool.SegmentLength;
var rows = Math.DivRem(dataLength, segmentLength, out var pos);
if (pos > 0)
{
rows++;
}
else
{
pos = segmentLength;
}
var bytes = SegmentPool.RentContainer();
for (var i = 0; i < rows; i++)
{
var row = SegmentPool.Rent();
stream.ReadExact(row, 0, i == rows - 1 ? pos : segmentLength);
bytes.Add(row);
}
data = new MultiArray <byte>(bytes, 0, dataLength);
}
#endif
return(new SerializedObject(data, dataType, serializerMimeType));
}
public void IndexatorTest_GetValueValueIntoIndexWhichIsOutOfRange_ShouldThrowIndexOutOfRangeException()
{
MultiArray <int> array = new MultiArray <int>(intArray, -1);
int value = array[-5];
}
public MultiArray <byte> Compress(MultiArray <byte> source) => _implementation.Compress(source);
