public Order DataToBusiness(DataOrder dataOrder)
{
Order returned = new Order();
returned.Items = new List <BasketItem>();
returned.Id = dataOrder.Id;
returned.UserId = dataOrder.UserId;
returned.OrderDate = dataOrder.OrderDate;
returned.Status = dataOrder.Status;
returned.Currency = dataOrder.Currency;
returned.City = dataOrder.City;
returned.DeliveryAddress = dataOrder.DeliveryAddress;
returned.IsDelivered = dataOrder.IsDelivered;
returned.InvoiceAddress = dataOrder.InvoiceAddress;
returned.PostalCode = dataOrder.PostalCode;
returned.DeliveryPrice = dataOrder.DeliveryPrice;
returned.TotalPrice = dataOrder.TotalPrice;
returned.ItemPrice = dataOrder.ItemPrice;
List <string> ids = dataOrder.RecipesIdList.Split(",").ToList();
List <string> quantity = dataOrder.RecipesQuantityList.Split(",").ToList();
for (int i = 0; i < ids.Count - 1; i++)
{
BasketItem temp = new BasketItem();
temp.RecipeId = Convert.ToInt32(ids[i]);
temp.Amount = Convert.ToInt32(quantity[i]);
returned.Items.Add(temp);
}
return(returned);
}
public void OpenForm()
{
DataOrder.Load();
DataTable dt = DataOrder.DBOperation();
DataView dv = new DataView(dt);
bsOrder.DataSource = dv;
dgvOrder.DataSource = bsOrder;
//фильтры
if (dgvOrder.Rows.Count > 0)
{
cbCustomer.DataSource = dv.ToTable(true, "Код клиента");
cbCustomer.DisplayMember = "Код клиента";
cbCustomer.Text = String.Empty;
btDelCustomer.Visible = false;
cbEmployee.DataSource = dv.ToTable(true, "Код сотрудника");
cbEmployee.DisplayMember = "Код сотрудника";
cbEmployee.Text = String.Empty;
btDelEmployee.Visible = false;
cbCourier.DataSource = dv.ToTable(true, "Код курьера");
cbCourier.DisplayMember = "Код курьера";
cbCourier.Text = String.Empty;
btDelCourier.Visible = false;
}
}
private void btDelete_Click(object sender, EventArgs e)
{
string del = dgvOrder.CurrentRow.Cells[0].ToString();
DataOrder.Delete(del);
OpenForm();
}
public async Task <Order> UpdateOrder(Order order)
{
DataOrder transformed = BusinessToData(order);
string orderAsJson = JsonSerializer.Serialize(transformed, serializeOptions);
Console.WriteLine("request" + orderAsJson);
HttpContent content = new StringContent(
orderAsJson,
Encoding.UTF8,
"application/json");
HttpResponseMessage response = await client.PutAsync(uri + "/UpdateOrder", content);
if (!response.IsSuccessStatusCode)
{
APIError apiError = JsonSerializer.Deserialize <APIError>(await response.Content.ReadAsStringAsync());
throw new Exception($@"Error: {apiError.message}");
}
string result = await response.Content.ReadAsStringAsync();
DataOrder gotOrders = JsonSerializer.Deserialize <DataOrder>(result,
new JsonSerializerOptions {
PropertyNamingPolicy = JsonNamingPolicy.CamelCase
});
Order returned = DataToBusiness(gotOrders);
Console.WriteLine("result" + result);
return(returned);
}
/// <summary>
/// 更新数据方法
/// </summary>
/// <param name="lst">列表对象</param>
private void UpdateData(Models.DataBaseRecord rec, DataOrder dataorder)
{
if (dataorder == DataOrder.Cooling)
{
var result = from buff in recLst where string.IsNullOrEmpty(buff.temperature4) && buff.serialNumber == rec.serialNumber select buff;
if (result == null)
{
return;
}
if (result.ToList().Count == 0)
{
recLst.Add(rec);
}
else
{
Models.DataBaseRecord bu = result.ToList()[0];
bu.coolingTime = (timeSecondCooling).ToString("f1");
bu.pressure = rec.pressure;
bu.temperature4 = rec.temperature4;
bu.flow1 = rec.flow1;
bu.flow2 = rec.flow2;
bu.flow3 = rec.flow3;
}
}
else if (dataorder == DataOrder.Heat)
{
recLst.Add(rec);
}
BinaryFile.FileName = fileName;
BinaryFile.SaveBinary(recLst.ConvertAll(s => (object)s));
}
public void SortByTime()
{
IComparer c = new TimeComparator();
Sort(c);
this.currentOrder = DataOrder.TimeOrder;
} /* SortByTime */
} /* SortByTime */
public void SortByDepth()
{
IComparer c = new DepthComparator();
Sort(c);
this.currentOrder = DataOrder.DepthOrder;
} /* SortByTime */
protected override void ReadBody(BinaryReader reader)
{
reader.ReadBytes(3);
var outputFalgs = reader.ReadByte();
OutputType = (OutputType)(outputFalgs & OutputTypeFlag);
BitOrder = (outputFalgs & BitOrderFlag) != 0 ? DataOrder.Reversed : DataOrder.Normal;
ByteOrder = (outputFalgs & ByteOrderFlag) != 0 ? DataOrder.Reversed : DataOrder.Normal;
}
public IApduCommand GetApdu(ConfigurationType configurationType, OutputType outputType, DataOrder bitOrder,
DataOrder byteOrder)
{
var outputFalgs = (byte)((int)outputType | (int)bitOrder << 1 | (int)byteOrder << 2);
return(GenerateApdu(new[] { outputFalgs }, (byte)ApplicationTag.ReaderInformation, (byte)OperationTag.Set,
(byte)ConfigurationSectionTag.CommonContactlessConfiguration,
(byte)configurationType, (byte)KbWedgeConfigCommand.KbwFlags));
}
/// <summary>
/// Move order
/// </summary>
/// <param name="type">Type of system</param>
/// <param name="market">Market</param>
/// <param name="order">Order data</param>
public DataOrder OrderMove(SysType type, MarketType market, Order order)
{
DataOrder result = null;
// check params
if (type == SysType.Empty)
{
throw new ArgumentNullException("type");
}
if (market == MarketType.Empty)
{
throw new ArgumentNullException("market");
}
if (order == null)
{
throw new ArgumentNullException("order");
}
// request formation
var request = type == SysType.Real ? new Request(MethodType.OrderMove) : new Request(MethodType.DemoMove);
request.Params.Add("market", EnumValue.GetValue(market));
request.Params.Add("id", order.OrderID);
request.Params.Add("price", order.Price);
request.Prepare(public_key, private_key);
// request execution
var response = ExecQuery(request);
// response analysis
if (response.IsSuccessfully)
{
result = (response.ResponseObject as ResponseOrderResult)?.Data;
}
else
{
string mess = string.Empty;
if (string.IsNullOrWhiteSpace(response?.RetMessage))
{
mess = "Empty error message";
}
else
{
var res = JsonConvert.DeserializeObject <ResponseBase>(response?.RetMessage);
mess = res.Message;
}
result = new DataOrder
{
ErrorMessage = mess
};
}
return(result);
}
/// <summary>
/// Gets an unsigned data type from the buffer with the specified order and transformation.
/// </summary>
/// <param name="type"></param>
/// <param name="order"></param>
/// <param name="transformation"></param>
/// <returns></returns>
public ulong GetUnsigned(DataType type, DataOrder order, DataTransformation transformation)
{
ulong longValue = Get(type, order, transformation);
if (type == DataType.LONG)
{
throw new Exception("due to java restrictions, longs must be read as signed types");
}
return(longValue & 0xFFFFFFFFFFFFFFFFL);
}
private void AreOrdersEqual(DataOrder order1, DataOrder order2)
{
Assert.AreEqual(order1.By.Count, order2.By.Count);
for (var i = 0; i < order1.By.Count; i++)
{
var item1 = order1.By[0];
var item2 = order2.By[0];
Assert.AreEqual(item1.Field, item2.Field);
Assert.AreEqual(item1.Direction, item2.Direction);
Assert.AreEqual(item1.OrderByDescending, item2.OrderByDescending);
}
}
/**
* Gets a signed data type from the buffer with the specified order and transformation.
*
* @param type The data type.
* @param order The byte order.
* @param transformation The data transformation.
* @return The value.
* @throws IllegalStateException If this reader is not in byte access mode.
* @throws IllegalArgumentException If the combination is invalid.
*/
public long GetSigned(MessageType type, DataOrder order, DataTransformation transformation)
{
long longValue = Get(type, order, transformation);
if (type != MessageType.Long)
{
int max = (int)(Math.Pow(2, (int)type * 8 - 1) - 1);
if (longValue > max)
{
longValue -= (max + 1) * 2;
}
}
return(longValue);
}
/// <summary>
/// Gets a signed data type from the buffer with the specified order and transformation.
/// </summary>
/// <param name="type"></param>
/// <param name="order"></param>
/// <param name="transformation"></param>
/// <returns></returns>
public ulong GetSigned(DataType type, DataOrder order, DataTransformation transformation)
{
ulong longValue = Get(type, order, transformation);
if (type != DataType.LONG)
{
uint max = (uint)(int)(Math.Pow(2, (int)type * 8 - 1) - 1);
if (longValue > max)
{
longValue -= (max + 1) * 2;
}
}
return(longValue);
}
public List <DataOrder> Orders()
{
List <DataOrder> orders = new List <DataOrder>();
List <DataOrderItem> items = new List <DataOrderItem>();
string id = "8ec5b379-90f5-11e9-b0f5-005056a73cc6";
// stored procedure
data.Conn.Open();
MySqlCommand Com = new MySqlCommand();
Com.Connection = data.Conn;
Com.CommandText = "bestellingen ";
Com.CommandType = CommandType.StoredProcedure;
Com.Parameters.AddWithValue("@customid", id);
Com.Parameters["@customid"].Direction = ParameterDirection.Input;
Com.ExecuteNonQuery();
MySqlDataReader reader = Com.ExecuteReader();
try
{
//read through all the data
while (reader.Read())
{
//create productlist
DataOrder order = new DataOrder();
DataOrderItem itemr = new DataOrderItem();
order.Id = reader.GetInt32("Id");
order.CustomId = reader.GetChar("CustomUser_Id");
order.TotalPrice = reader.GetDecimal("totalprice");
itemr.ProductName = reader.GetString("Name");
itemr.Price = reader.GetDecimal("Sellprice");
// save uitlening to the list
orders.Add(order);
items.Add(itemr);
}
}
catch
{
Console.WriteLine("kan de query niet uitvoeren! LOL");
}
data.Conn.Close();
return(orders);
}
private void button1_Click(object sender, EventArgs e)
{
string customer = tbCustomer.Text;
string map = tbMap.Text;
string employee = tbEmployee.Text;
string courier = tbCourier.Text;
string accommodation = tbAccommodation.Text;
string purpose = tbPurpose.Text;
string execution = tbExecution.Text;
DataOrder.Insert(customer, map, employee, courier, accommodation, purpose, execution);
OrderForm orderform = new OrderForm();
orderform.OpenForm();
orderform.Show();
this.Close();
}
public DataOrder AddOrder([FromBody] Order Orderx)
{
var text = "OD";
var textsub = text.Substring(0, 1).ToString();
var id = Guid.NewGuid().ToString();
var textid = text + "-" + id.Substring(0, 4);
// var split = id.Split("",5).ToString();
// var textID = text + split.ToString() ;
var item = new Order
{
IdOrder = textid,
IdProduct = Orderx.IdProduct,
NameProduct = Orderx.NameProduct,
AmountProduct = Orderx.AmountProduct,
PriceOrder = Orderx.PriceOrder,
NameUser = Orderx.NameUser,
AddressUser = Orderx.AddressUser,
TelUser = Orderx.TelUser,
UserOrder = Orderx.UserOrder,
DateOrder = DateTime.Now.ToString("dd/MM/yyyy"),
Status = "สั่งซื้อ"
};
var item2 = new DataOrder
{
IdOrder = textid,
IdProduct = Orderx.IdProduct,
NameProduct = Orderx.NameProduct,
AmountProduct = Orderx.AmountProduct,
PriceOrder = Orderx.PriceOrder,
NameUser = Orderx.NameUser,
AddressUser = Orderx.AddressUser,
TelUser = Orderx.TelUser,
UserOrder = Orderx.UserOrder,
DateOrder = DateTime.Now.ToString("dd/MM/yyyy"),
Status = "สั่งซื้อ"
};
MirrorDataOrder.Add(item2);
DataOrder.Add(item);
return(item2);
}
public async Task <Order> GetOrder(int id)
{
HttpResponseMessage response = await client.GetAsync(uri + $"/GetOrder?id={id}");
if (!response.IsSuccessStatusCode)
{
APIError apiError = JsonSerializer.Deserialize <APIError>(await response.Content.ReadAsStringAsync());
throw new Exception($@"Error: {apiError.message}");
}
string result = await response.Content.ReadAsStringAsync();
DataOrder gotOrders = JsonSerializer.Deserialize <DataOrder>(result,
new JsonSerializerOptions {
PropertyNamingPolicy = JsonNamingPolicy.CamelCase
});
Order returned = DataToBusiness(gotOrders);
Console.WriteLine("result" + result);
return(returned);
}
public DataOrder BusinessToData(Order order)
{
DataOrder returned = new DataOrder();
returned.Id = order.Id;
returned.UserId = order.UserId;
returned.OrderDate = order.OrderDate;
returned.Status = order.Status;
returned.Currency = order.Currency;
returned.City = order.City;
returned.DeliveryAddress = order.DeliveryAddress;
returned.IsDelivered = order.IsDelivered;
returned.InvoiceAddress = order.InvoiceAddress;
returned.PostalCode = order.PostalCode;
returned.DeliveryPrice = order.DeliveryPrice;
returned.TotalPrice = order.TotalPrice;
returned.ItemPrice = order.ItemPrice;
foreach (var item in order.Items)
{
returned.RecipesIdList = returned.RecipesIdList + item.RecipeId + ",";
returned.RecipesQuantityList += item.Amount + ",";
}
return(returned);
}
/**
* Gets an unsigned data type from the buffer with the specified order.
*
* @param type The data type.
* @param order The byte order.
* @return The value.
* @throws IllegalStateException If this reader is not in byte access mode.
* @throws IllegalArgumentException If the combination is invalid.
*/
public ulong GetUnsigned(MessageType type, DataOrder order)
{
return(GetUnsigned(type, order, DataTransformation.None));
}
/// <summary>
/// Gets an unsigned data type from the buffer with the specified order.
/// </summary>
/// <param name="type"></param>
/// <param name="order"></param>
/// <returns></returns>
public ulong GetUnsigned(DataType type, DataOrder order)
{
return(GetUnsigned(type, order, DataTransformation.NONE));
}
/**
* Puts a standard data type with the specified value, byte order and
* transformation.
* @param type The data type.
* @param order The byte order.
* @param transformation The transformation.
* @param value The value.
* @throws IllegalStateException if this reader is not in byte access mode.
* @throws ArgumentException if the combination is invalid.
*/
public void Put(MessageType type, DataOrder order, DataTransformation transformation, long value)
{
CheckByteAccess();
int length = (int)type;
if (order == DataOrder.Big)
{
for (int i = length - 1; i >= 0; i--)
{
if (i == 0 && transformation != DataTransformation.None)
{
if (transformation == DataTransformation.Add)
{
Buffer.WriteByte((byte)(value + 128));
}
else if (transformation == DataTransformation.Negate)
{
Buffer.WriteByte((byte)-value);
}
else if (transformation == DataTransformation.Subtract)
{
Buffer.WriteByte((byte)(128 - value));
}
else
{
throw new ArgumentException("unknown transformation");
}
}
else
{
Buffer.WriteByte((byte)(value >> i * 8));
}
}
}
else if (order == DataOrder.Little)
{
for (int i = 0; i < length; i++)
{
if (i == 0 && transformation != DataTransformation.None)
{
if (transformation == DataTransformation.Add)
{
Buffer.WriteByte((byte)(value + 128));
}
else if (transformation == DataTransformation.Negate)
{
Buffer.WriteByte((byte)-value);
}
else if (transformation == DataTransformation.Subtract)
{
Buffer.WriteByte((byte)(128 - value));
}
else
{
throw new ArgumentException("unknown transformation");
}
}
else
{
Buffer.WriteByte((byte)(value >> i * 8));
}
}
}
else if (order == DataOrder.Middle)
{
if (transformation != DataTransformation.None)
{
throw new ArgumentException("middle endian cannot be transformed");
}
if (type != MessageType.Int)
{
throw new ArgumentException("middle endian can only be used with an integer");
}
Buffer.WriteByte((byte)(value >> 8));
Buffer.WriteByte((byte)value);
Buffer.WriteByte((byte)(value >> 24));
Buffer.WriteByte((byte)(value >> 16));
}
else if (order == DataOrder.InversedMiddle)
{
if (transformation != DataTransformation.None)
{
throw new ArgumentException("inversed middle endian cannot be transformed");
}
if (type != MessageType.Int)
{
throw new ArgumentException("inversed middle endian can only be used with an integer");
}
Buffer.WriteByte((byte)(value >> 16));
Buffer.WriteByte((byte)(value >> 24));
Buffer.WriteByte((byte)value);
Buffer.WriteByte((byte)(value >> 8));
}
else
{
throw new ArgumentException("unknown order");
}
}
/**
* Puts a standard data type with the specified value and byte order.
* @param type The data type.
* @param order The byte order.
* @param value The value.
* @throws IllegalStateException if this reader is not in byte access mode.
* @throws ArgumentException if the combination is invalid.
*/
public void Put(MessageType type, DataOrder order, long value)
{
Put(type, order, DataTransformation.None, value);
}
public List <SalesLineItem> GetSalesLineItemsFromOrderID(int id)
{
DataOrder orderAccess = new DataOrder();
return(orderAccess.GetSalesLineItemsFromOrderID(id));
}
/// <summary>
/// Reads a standard data type from the buffer with the specified order and transformation.
/// </summary>
/// <param name="type"></param>
/// <param name="order"></param>
/// <param name="transformation"></param>
/// <returns></returns>
private ulong Get(DataType type, DataOrder order, DataTransformation transformation)
{
CheckByteAccess();
ulong longValue = 0;
int length = (int)type;
if (order == DataOrder.BIG)
{
for (int index = length - 1; index >= 0; index--)
{
if (index == 0 && transformation != DataTransformation.NONE)
{
if (transformation == DataTransformation.ADD)
{
longValue |= (uint)buffer.ReadByte() - 128 & 0xFF;
}
else if (transformation == DataTransformation.NEGATE)
{
longValue |= (uint)-buffer.ReadByte() & 0xFF;
}
else if (transformation == DataTransformation.SUBTRACT)
{
longValue |= (uint)128 - buffer.ReadByte() & 0xFF;
}
else
{
throw new Exception("unknown transformation");
}
}
else
{
longValue |= (uint)(buffer.ReadByte() & 0xFF) << index * 8;
}
}
}
else if (order == DataOrder.LITTLE)
{
for (int index = 0; index < length; index++)
{
if (index == 0 && transformation != DataTransformation.NONE)
{
if (transformation == DataTransformation.ADD)
{
longValue |= (uint)buffer.ReadByte() - 128 & 0xFF;
}
else if (transformation == DataTransformation.NEGATE)
{
longValue |= (uint)-buffer.ReadByte() & 0xFF;
}
else if (transformation == DataTransformation.SUBTRACT)
{
longValue |= (uint)128 - buffer.ReadByte() & 0xFF;
}
else
{
throw new Exception("unknown transformation");
}
}
else
{
longValue |= (uint)(buffer.ReadByte() & 0xFF) << index * 8;
}
}
}
else if (order == DataOrder.MIDDLE)
{
if (transformation != DataTransformation.NONE)
{
throw new Exception("middle endian cannot be transformed");
}
if (type != DataType.INT)
{
throw new Exception("middle endian can only be used with an integer");
}
longValue |= (uint)(buffer.ReadByte() & 0xFF) << 8;
longValue |= (uint)buffer.ReadByte() & 0xFF;
longValue |= (uint)(buffer.ReadByte() & 0xFF) << 24;
longValue |= (uint)(buffer.ReadByte() & 0xFF) << 16;
}
else if (order == DataOrder.INVERSED_MIDDLE)
{
if (transformation != DataTransformation.NONE)
{
throw new Exception("inversed middle endian cannot be transformed");
}
if (type != DataType.INT)
{
throw new Exception("inversed middle endian can only be used with an integer");
}
longValue |= (uint)(buffer.ReadByte() & 0xFF) << 16;
longValue |= (uint)(buffer.ReadByte() & 0xFF) << 24;
longValue |= (uint)buffer.ReadByte() & 0xFF;
longValue |= (uint)(buffer.ReadByte() & 0xFF) << 8;
}
else
{
throw new Exception("unknown order");
}
return(longValue);
}
/// <summary>
/// Puts a standard data type with the specified value, byte order and transformation.
/// </summary>
/// <param name="type"></param>
/// <param name="order"></param>
/// <param name="transformation"></param>
/// <param name="value"></param>
public void Put(DataType type, DataOrder order, DataTransformation transformation, long value)
{
CheckByteAccess();
int length = (int)type;
switch (order)
{
case DataOrder.BIG:
for (int index = length - 1; index >= 0; index--)
{
if (index == 0 && transformation != DataTransformation.NONE)
{
if (transformation == DataTransformation.ADD)
{
buffer.WriteByte((byte)(value + 128));
}
else if (transformation == DataTransformation.NEGATE)
{
buffer.WriteByte((byte)-value);
}
else if (transformation == DataTransformation.SUBTRACT)
{
buffer.WriteByte((byte)(128 - value));
}
else
{
throw new Exception("Unknown transformation.");
}
}
else
{
buffer.WriteByte((byte)(value >> index * 8));
}
}
break;
case DataOrder.INVERSED_MIDDLE:
if (transformation != DataTransformation.NONE)
{
throw new Exception("Inversed middle endian cannot be transformed.");
}
if (type != DataType.INT)
{
throw new Exception("Inversed middle endian can only be used with an integer.");
}
buffer.WriteByte((byte)(value >> 16));
buffer.WriteByte((byte)(value >> 24));
buffer.WriteByte((byte)value);
buffer.WriteByte((byte)(value >> 8));
break;
case DataOrder.LITTLE:
for (int index = 0; index < length; index++)
{
if (index == 0 && transformation != DataTransformation.NONE)
{
if (transformation == DataTransformation.ADD)
{
buffer.WriteByte((byte)(value + 128));
}
else if (transformation == DataTransformation.NEGATE)
{
buffer.WriteByte((byte)-value);
}
else if (transformation == DataTransformation.SUBTRACT)
{
buffer.WriteByte((byte)(128 - value));
}
else
{
throw new Exception("Unknown transformation.");
}
}
else
{
buffer.WriteByte((byte)(value >> index * 8));
}
}
break;
case DataOrder.MIDDLE:
if (transformation != DataTransformation.NONE)
{
throw new Exception("Middle endian cannot be transformed.");
}
if (type != DataType.INT)
{
throw new Exception("Middle endian can only be used with an integer.");
}
buffer.WriteByte((byte)(value >> 8));
buffer.WriteByte((byte)value);
buffer.WriteByte((byte)(value >> 24));
buffer.WriteByte((byte)(value >> 16));
break;
}
}
/**
* Gets an unsigned data type from the buffer with the specified order and transformation.
*
* @param type The data type.
* @param order The byte order.
* @param transformation The data transformation.
* @return The value.
* @throws IllegalStateException If this reader is not in byte access mode.
* @throws IllegalArgumentException If the combination is invalid.
*/
public ulong GetUnsigned(MessageType type, DataOrder order, DataTransformation transformation)
{
long longValue = Get(type, order, transformation);
return(((ulong)longValue) & 0xFFFFFFFFFFFFFFFFL);
}
public List <Order> GetAllOrders()
{
DataOrder orderAccess = new DataOrder();
return(orderAccess.GetAllOrders());
}
/**
* Reads a standard data type from the buffer with the specified order and transformation.
*
* @param type The data type.
* @param order The data order.
* @param transformation The data transformation.
* @return The value.
* @throws IllegalStateException If this reader is not in byte access mode.
* @throws IllegalArgumentException If the combination is invalid.
*/
private long Get(MessageType type, DataOrder order, DataTransformation transformation)
{
CheckByteAccess();
long longValue = 0;
int length = (int)type;
if (order == DataOrder.Big)
{
for (int i = length - 1; i >= 0; i--)
{
if (i == 0 && transformation != DataTransformation.None)
{
if (transformation == DataTransformation.Add)
{
longValue |= _buffer.ReadByte() - 128 & 0xFFL;
}
else if (transformation == DataTransformation.Negate)
{
longValue |= -_buffer.ReadByte() & 0xFFL;
}
else if (transformation == DataTransformation.Subtract)
{
longValue |= 128 - _buffer.ReadByte() & 0xFFL;
}
else
{
throw new ArgumentException("Unknown transformation.");
}
}
else
{
longValue |= (_buffer.ReadByte() & 0xFFL) << i * 8;
}
}
}
else if (order == DataOrder.Little)
{
for (int i = 0; i < length; i++)
{
if (i == 0 && transformation != DataTransformation.None)
{
if (transformation == DataTransformation.Add)
{
longValue |= _buffer.ReadByte() - 128 & 0xFFL;
}
else if (transformation == DataTransformation.Negate)
{
longValue |= -_buffer.ReadByte() & 0xFFL;
}
else if (transformation == DataTransformation.Subtract)
{
longValue |= 128 - _buffer.ReadByte() & 0xFFL;
}
else
{
throw new ArgumentException("Unknown transformation.");
}
}
else
{
longValue |= (_buffer.ReadByte() & 0xFFL) << i * 8;
}
}
}
else if (order == DataOrder.Middle)
{
if (transformation != DataTransformation.None)
{
throw new ArgumentException("Middle endian cannot be transformed.");
}
if (type != MessageType.Int)
{
throw new ArgumentException("Middle endian can only be used with an integer.");
}
longValue |= (_buffer.ReadByte() & 0xFF) << 8;
longValue |= _buffer.ReadByte() & 0xFF;
longValue |= (_buffer.ReadByte() & 0xFF) << 24;
longValue |= (_buffer.ReadByte() & 0xFF) << 16;
}
else if (order == DataOrder.InversedMiddle)
{
if (transformation != DataTransformation.None)
{
throw new ArgumentException("Inversed middle endian cannot be transformed.");
}
if (type != MessageType.Int)
{
throw new ArgumentException("Inversed middle endian can only be used with an integer.");
}
longValue |= (_buffer.ReadByte() & 0xFF) << 16;
longValue |= (_buffer.ReadByte() & 0xFF) << 24;
longValue |= _buffer.ReadByte() & 0xFF;
longValue |= (_buffer.ReadByte() & 0xFF) << 8;
}
else
{
throw new ArgumentException("Unknown order.");
}
return(longValue);
}
/// <summary>
/// Puts a standard data type with the specified value and byte order.
/// </summary>
/// <param name="type"></param>
/// <param name="order"></param>
/// <param name="value"></param>
public void Put(DataType type, DataOrder order, long value)
{
Put(type, order, DataTransformation.NONE, value);
}
