public static void Draw(GameTime Time)
{
PrivateDrawFramesPerSecond++;
SecondTimer += (float) Time.ElapsedGameTime.TotalSeconds;
if (SecondTimer >= 1)
{
SecondTimer--;
DrawFramesPerSecond = PrivateDrawFramesPerSecond;
PrivateDrawFramesPerSecond = 0;
if (DrawFramesPerSecondBuffer != null)
{
DrawFramesPerSecondBuffer[(DrawFramesPerSecondBufferIndex ?? (DrawFramesPerSecondBuffer.Length - 1))
] = DrawFramesPerSecond;
if (DrawFramesPerSecondBufferIndex == null) DrawFramesPerSecondBufferIndex = 0;
else
{
if (DrawFramesPerSecondBufferIndex >= (DrawFramesPerSecondBuffer.Length - 1))
DrawFramesPerSecondBufferIndex = null;
else DrawFramesPerSecondBufferIndex++;
}
if (DrawFramesPerSecondBufferRecorded < DrawFramesPerSecondBuffer.Length)
DrawFramesPerSecondBufferRecorded++;
}
}
}
public void Setup()
{
//Instance Fields Setup
BooleanField = null;
ByteField = null;
SByteField = null;
IntField = null;
LongField = null;
Int16Field = null;
UInt16Field = null;
Int32Field = null;
UInt32Field = null;
Int64Field = null;
UInt64Field = null;
CharField = null;
DoubleField = null;
FloatField = null;
//Static Fields Setup
BooleanFieldStatic = null;
ByteFieldStatic = null;
SByteFieldStatic = null;
IntFieldStatic = null;
LongFieldStatic = null;
Int16FieldStatic = null;
UInt16FieldStatic = null;
Int32FieldStatic = null;
UInt32FieldStatic = null;
Int64FieldStatic = null;
UInt64FieldStatic = null;
CharFieldStatic = null;
DoubleFieldStatic = null;
FloatFieldStatic = null;
}
public ID3v1Tag(byte[] bytes)
{
if (bytes.Length < TagLength || Encoding.ASCII.GetString(bytes, bytes.Length - TagLength, 3) != "TAG")
throw new InvalidDataException("No ID3 tag found");
ArraySegment<byte> tag = new ArraySegment<byte>(bytes, bytes.Length - TagLength, TagLength);
_title = Encoding.ASCII.GetString(tag.Array, tag.Offset + TitleOffset, MaxFieldLength).TrimEnd('\0');
_artist = Encoding.ASCII.GetString(tag.Array, tag.Offset + ArtistOffset, MaxFieldLength).TrimEnd('\0');
_album = Encoding.ASCII.GetString(tag.Array, tag.Offset + AlbumOffset, MaxFieldLength).TrimEnd('\0');
short year;
if (short.TryParse(Encoding.ASCII.GetString(tag.Array, tag.Offset + YearOffset, 4), out year))
_year = year;
if (tag.Array[tag.Offset + TrackOffset - 1] == 0)
{
_comment = Encoding.ASCII.GetString(tag.Array, tag.Offset + CommentOffset, MaxFieldLength - 2).TrimEnd('\0');
_track = tag.Array[tag.Offset + TrackOffset];
}
else
{
_comment = Encoding.ASCII.GetString(tag.Array, tag.Offset + CommentOffset, MaxFieldLength).TrimEnd('\0');
}
Genre = (Genre)tag.Array[tag.Offset + GenreOffset];
}
public HslPixel(float hue, float saturation, float luminance)
{
this.hue = hue;
this.saturation = saturation;
this.luminance = luminance;
this.normalizedValue = null;
}
public byte ReadBits(int count)
{
Guard.ArgumentBetweenInclusive("count", count, 0, 8);
if (_streamPositionAfterBitReading != this.BaseStream.Position) // there was byte reading operation
ClearBuffer();
if (_buffer == null || BitsInBuffer == 0)
{
_buffer = ReadByte();
_bufferPosition = 0;
_streamPositionAfterBitReading = this.BaseStream.Position;
}
byte result;
if (BitsInBuffer >= count)
{
result = GetValueFromBuffer(count);
}
else
{
byte nextByteBitsCount = (byte) (count - BitsInBuffer);
byte value = GetValueFromBuffer(BitsInBuffer);
byte lowBits = ReadBits(nextByteBitsCount);
result = (byte)((value << nextByteBitsCount) + lowBits);
}
return result;
}
public override void Refresh(bool volatileOnly)
{
base.Refresh(volatileOnly);
if (!volatileOnly)
cachedFanData = null;
((ControllerBase)Controller).Refresh(this);
}
private DateTimePropertyConfiguration(DateTimePropertyConfiguration source)
: base(source)
{
Contract.Requires(source != null);
Precision = source.Precision;
}
private DateTimePropertyConfiguration(DateTimePropertyConfiguration source)
: base(source)
{
DebugCheck.NotNull(source);
Precision = source.Precision;
}
public Rgb(String Raw)
{
string[] val = Raw.Split(';');
this.redByte = Convert.ToByte(val[0]);
this.greenByte = Convert.ToByte(val[1]);
this.blueByte = Convert.ToByte(val[2]);
}
public TileFrame(string tf)
{
TileFrame TF;
TryParse(tf, out TF);
_tile = TF.Tile;
_frame = TF.Frame;
}
public void FlushBits()
{
if (_buffer != null)
Write(_buffer.Value);
_buffer = null;
_bufferPosition = 0;
}
public int GetMetadataLength()
{
if (this._streamId <= byte.MaxValue)
this._slen = 0x00;
else if (this._streamId <= ushort.MaxValue)
this._slen = 0x01;
else if (this._streamId <= 16777215)
this._slen = 0x02;
else
this._slen = 0x03;
if (this._offset == 0)
this._olen = 0x00;
else if (this._offset < 65536) // 16 bits
this._olen = 0x01;
else if (this._offset < 16777216) // 24 bits
this._olen = 0x02;
else if (this._offset < 4294967296) // 32 bits
this._olen = 0x03;
else if (this._offset < 1099511627776) // 40 bits
this._olen = 0x04;
else if (this._offset < 281474976710656) // 48 bits
this._olen = 0x05;
else if (this._offset < 72057594037927936) // 56 bits
this._olen = 0x06;
else // 64 bits
this._olen = 0x07;
// INFO: We're going to just always send data length (+2)
this._metadataLength = 1 + (this._slen.Value + 1) * 8 + (this._olen.Value == 0 ? 0 : (this._olen.Value + 1) * 8) + 2;
return this._metadataLength.Value;
}
public SerialPacketManager(SerialPort port, SerialConfig config) : this(port)
{
receiverStart = PACKET_SIZED_START_BYTE;
if (config.RxPacketType == PacketType.SimpleCRC || config.RxPacketType == PacketType.SizedCRC || config.RxPacketType == PacketType.SizedCRC_old)
{
receiverCRCValue = config.ReceiverCRC;
}
if (config.TxPacketType == PacketType.SimpleCRC || config.TxPacketType == PacketType.SizedCRC || config.TxPacketType == PacketType.SizedCRC_old)
{
transmitterCRCValue = config.TransmitterCRC;
}
if (config.RxPacketType == PacketType.SizedOld || config.RxPacketType == PacketType.SizedCRC_old)
{
receiverEnd = PACKET_END_TRANSMIT;
}
if (config.TxPacketType == PacketType.SizedOld || config.TxPacketType == PacketType.SizedCRC_old)
{
transmitterEnd = PACKET_END_TRANSMIT;
}
if (config.RxPacketType == PacketType.Simple || config.RxPacketType == PacketType.SimpleCoded || config.RxPacketType == PacketType.SimpleCRC)
{
receiverStart = PACKET_UNSIZED_START_BYTE;
receiverEnd = PACKET_END_TEXT;
}
if (config.TxPacketType == PacketType.Simple || config.TxPacketType == PacketType.SimpleCoded || config.TxPacketType == PacketType.SimpleCRC)
{
transmitterStart = PACKET_UNSIZED_START_BYTE;
transmitterEnd = PACKET_END_TEXT;
}
}
internal static State Simulate(this State s, int transitionToUse = 0, params byte?[] inputChars)
{
if (inputChars == null)
inputChars = new byte?[] {null};
State currentState = s;
int pos = 0;
foreach (var inputChar in inputChars)
{
var ic = inputChar == null ? InputChar.Epsilon() : InputChar.For((byte) inputChar);
List<State> transitions;
if (!currentState.Transitions.TryGetValue(ic, out transitions))
ThrowSimulationException(inputChar, pos);
if (transitions.Count > transitionToUse)
{
currentState = transitions[transitionToUse];
}
else if (transitions.Count > 0)
{
currentState = transitions[0];
}
else
{
ThrowSimulationException(inputChar, pos);
}
pos++;
}
return currentState;
}
public static void CheckUnaryArithmeticNegateNullableByteTest(bool useInterpreter)
{
byte?[] values = new byte?[] { null, 0, 1, byte.MaxValue };
for (int i = 0; i < values.Length; i++)
{
VerifyArithmeticNegateNullableByte(values[i], useInterpreter);
}
}
public static void CheckUnaryBitwiseNotNullableByteTest()
{
byte?[] values = new byte?[] { null, 0, 1, byte.MaxValue };
for (int i = 0; i < values.Length; i++)
{
VerifyBitwiseNotNullableByte(values[i]);
}
}
private DecimalPropertyConfiguration(DecimalPropertyConfiguration source)
: base(source)
{
Contract.Requires(source != null);
Precision = source.Precision;
Scale = source.Scale;
}
private DecimalPropertyConfiguration(DecimalPropertyConfiguration source)
: base(source)
{
DebugCheck.NotNull(source);
Precision = source.Precision;
Scale = source.Scale;
}
public static void CheckUnaryArithmeticNegateCheckedNullableByteTest()
{
byte?[] values = new byte?[] { null, 0, 1, byte.MaxValue };
for (int i = 0; i < values.Length; i++)
{
VerifyArithmeticNegateCheckedNullableByte(values[i]);
}
}
public static void Main()
{
// First variant
// Console.WriteLine(Convert.ToString(number, 2));
// Second variant
byte?[] N = new byte?[32]; // the number is type int, so the length is 32bits
for (byte i = 0; i < N.Length; i++) // fills the array with 0s
{
N[i] = 0;
}
Console.Write("Please, enter some integer number: ");
Console.ForegroundColor = ConsoleColor.Yellow;
int num = int.Parse(Console.ReadLine());
Console.ResetColor();
int temp = num;
if (num < 0) // if the number is negative
{
num = int.MaxValue + num + 1;
N[N.Length - 1] = 1; // sets 1 on the leftmost bit
}
while (num > 0) // checks where are the 1s
{
for (int i = 0; i < int.MaxValue; i++)
{
if (Math.Pow(2, i + 1) > num) // this finds where has to be 1
{
N[i] = 1; // sets 1 for this bit
num -= (int)Math.Pow(2, i); // decrease the number by this bit
break;
}
}
}
Array.Reverse(N); // reverses the array
for (int i = 0; i < N.Length; i++) // removes the first 0s from positive numbers
{
if (N[i] == 0) N[i] = null;
else break;
}
// Prints the result
Console.Write("Binary representation of this number is: ");
if (temp != 0)
{
Console.ForegroundColor = ConsoleColor.Green;
foreach (var item in N)
{
Console.Write(item);
}
}
else
{
Console.ForegroundColor = ConsoleColor.Green;
Console.Write(0);
}
Console.ResetColor();
Console.WriteLine();
}
/// <summary>
/// Copies this object's properties from another
/// </summary>
/// <param name="other">The object to copy from</param>
public override void CopyFrom(object other)
{
var di = other as DeviceInfo;
if(di != null)
{
base.CopyFrom(di);
this.DatabaseRevision = di.DatabaseRevision;
}
}
public PeekStream(Stream inner)
{
if (inner == null) {
throw new ArgumentNullException("inner");
}
this.inner = inner;
this.peek = null;
}
internal override void CopyFrom(PrimitivePropertyConfiguration other)
{
base.CopyFrom(other);
var strConfigRhs = other as DateTimePropertyConfiguration;
if (strConfigRhs != null)
{
Precision = strConfigRhs.Precision;
}
}
public BasicMidiChordDef(BasicMidiChordDef original, int msDuration)
{
_msDuration = msDuration; // read-only!
BankIndex = original.BankIndex;
PatchIndex = original.PatchIndex;
HasChordOff = original.HasChordOff;
Pitches = new List<byte>(original.Pitches);
Velocities = new List<byte>(original.Velocities);
}
internal override void FillFrom(PrimitivePropertyConfiguration other, bool inCSpace)
{
base.FillFrom(other, inCSpace);
var strConfigRhs = other as DateTimePropertyConfiguration;
if (strConfigRhs != null
&& Precision == null)
{
Precision = strConfigRhs.Precision;
}
}
internal override void CopyFrom(PrimitivePropertyConfiguration other)
{
base.CopyFrom(other);
var lenConfigRhs = other as DecimalPropertyConfiguration;
if (lenConfigRhs != null)
{
Precision = lenConfigRhs.Precision;
Scale = lenConfigRhs.Scale;
}
}
public ID3v1Tag()
{
_title = String.Empty;
_artist = String.Empty;
_album = String.Empty;
_year = null;
_comment = String.Empty;
_track = null;
Genre = Genre.None;
}
public static void CheckNonLiftedComparisonEqualNullableByteTest(bool useInterpreter)
{
byte?[] values = new byte?[] { null, 0, 1, byte.MaxValue };
for (int i = 0; i < values.Length; i++)
{
for (int j = 0; j < values.Length; j++)
{
VerifyComparisonEqualNullableByte(values[i], values[j], useInterpreter);
}
}
}
public static void CheckLiftedAddNullableByteTest()
{
byte?[] values = new byte?[] { null, 0, 1, byte.MaxValue };
for (int i = 0; i < values.Length; i++)
{
for (int j = 0; j < values.Length; j++)
{
VerifyAddNullableByte(values[i], values[j]);
}
}
}
public static void CheckNullableBytePowerTest()
{
byte?[] array = new byte?[] { null, 0, 1, byte.MaxValue };
for (int i = 0; i < array.Length; i++)
{
for (int j = 0; j < array.Length; j++)
{
VerifyNullableBytePower(array[i], array[j]);
}
}
}
/// <summary>
/// Set ConceptField field</summary>
/// <param name="conceptField_">Nullable field value to be set</param>
public void SetConceptField(byte?conceptField_)
{
SetFieldValue(1, 0, conceptField_, Fit.SubfieldIndexMainField);
}
internal static object NullCheck(byte?value)
{
return(value ?? (object)DBNull.Value);
}
/// <summary>
/// Set ScreenIndex field</summary>
/// <param name="screenIndex_">Nullable field value to be set</param>
public void SetScreenIndex(byte?screenIndex_)
{
SetFieldValue(0, 0, screenIndex_, Fit.SubfieldIndexMainField);
}
/// <summary>
/// Set DeviceType field</summary>
/// <param name="deviceType_">Nullable field value to be set</param>
public void SetDeviceType(byte?deviceType_)
{
SetFieldValue(1, 0, deviceType_, Fit.SubfieldIndexMainField);
}
public static byte[] Percent_Decode(ReadOnlyMemory <byte> input)
{/* Docs: https://url.spec.whatwg.org/#percent-decode */
DataConsumer <byte> Stream = new DataConsumer <byte>(input, byte.MinValue);
/* Create a list of memory chunks that make up the final string */
ulong newLength = 0;
ulong?chunkStart = null;
ulong chunkCount = 0;
var chunks = new LinkedList <Tuple <ReadOnlyMemory <byte>, byte?> >();
while (!Stream.atEnd)
{
EFilterResult filterResult = EFilterResult.FILTER_ACCEPT;
byte? bytePoint = null;
if (Stream.Next == CHAR_PERCENT && Is_Ascii_Hex_Digit((char)Stream.NextNext) && Is_Ascii_Hex_Digit((char)Stream.NextNextNext))
{
filterResult = EFilterResult.FILTER_SKIP;
uint low = (uint)Ascii_Hex_To_Value((char)Stream.NextNext);
uint high = (uint)Ascii_Hex_To_Value((char)Stream.NextNextNext);
bytePoint = (byte)(low | (high >> 4));
Stream.Consume(2);
break;
}
/* When filter result:
* ACCEPT: Char should be included in chunk
* SKIP: Char should not be included in chunk, if at chunk-start shift chunk-start past char, otherwise end chunk
* REJECT: Char should not be included in chunk, current chunk ends
*/
bool end_chunk = false;
switch (filterResult)
{
case EFilterResult.FILTER_ACCEPT: // Char should be included in the chunk
{
if (!chunkStart.HasValue)
{
chunkStart = Stream.LongPosition; /* Start new chunk (if one isnt started yet) */
}
}
break;
case EFilterResult.FILTER_REJECT: // Char should not be included in chunk, current chunk ends
{
end_chunk = true;
}
break;
case EFilterResult.FILTER_SKIP: // Char should not be included in chunk, if at chunk-start shift chunk-start past char, otherwise end chunk
{
if (!chunkStart.HasValue)
{
chunkStart = Stream.LongPosition + 1; /* At chunk-start */
}
else
{
end_chunk = true;
}
}
break;
}
if (end_chunk || Stream.Remaining <= 1)
{
if (!chunkStart.HasValue)
{
chunkStart = Stream.LongPosition;
}
/* Push new chunk to our list */
var chunkSize = Stream.LongPosition - chunkStart.Value;
var Mem = Stream.AsMemory().Slice((int)chunkStart.Value, (int)chunkSize);
var chunk = new Tuple <ReadOnlyMemory <byte>, byte?>(Mem, bytePoint);
chunks.AddLast(chunk);
chunkCount++;
chunkStart = null;
newLength += chunkSize;
/* If we actually decoded a byte then account for it in the newLength */
if (filterResult != EFilterResult.FILTER_ACCEPT)
{
newLength++;
}
}
Stream.Consume();
}
/* Compile the string */
var dataPtr = new byte[newLength];
Memory <byte> data = new Memory <byte>(dataPtr);
ulong index = 0;
foreach (var tpl in chunks)
{
var chunk = tpl.Item1;
/* Copy chunk data */
chunk.CopyTo(data.Slice((int)index));
index += (ulong)chunk.Length;
if (tpl.Item2.HasValue)
{
data.Span[(int)index] = tpl.Item2.Value;
index++;
}
}
return(dataPtr);
}
public Terminal(ITrayProcessCommunicationService trayProcessCommunicationService, byte?terminalId = null)
{
_trayProcessCommunicationService = trayProcessCommunicationService;
_trayProcessCommunicationService.TerminalExited += OnTerminalExited;
Id = terminalId ?? trayProcessCommunicationService.GetNextTerminalId();
_requireShellProcessStart = !terminalId.HasValue;
}
public void Delete(byte?id)
{
_unitOfWork.ApplicationRepository.IsDeleteTrue(id);
_unitOfWork.Save();
}
public override void WriteValue(byte?value)
{
_textWriter.WriteValue(value);
_innerWriter.WriteValue(value);
base.WriteValue(value);
}
static void FromUInt8()
{
Console.WriteLine("--- FromUInt8");
byte?[] a = new byte?[] { new byte?(), new byte?(20), new byte?(30) };
TestCore(a);
}
public void SetState(byte?value)
{
this.state_ = value;
}
public void SetCurrentStepState(byte?value)
{
this.currentStepState_ = value;
}
internal byte?NumberProperty(string propertyName, ref byte?output) => output = this.NullableProperty <JsonNumber>(propertyName)?.ToByte() ?? null;
private void WriteParameters(IEnumerable <IParameterDefinition> parameters, ITypeReference containingType, byte?methodNullableContextValue, bool property = false, bool extensionMethod = false, bool acceptsExtraArguments = false)
{
string start = property ? "[" : "(";
string end = property ? "]" : ")";
WriteSymbol(start);
_writer.WriteList(parameters, p =>
{
WriteParameter(p, containingType, extensionMethod, methodNullableContextValue);
extensionMethod = false;
});
if (acceptsExtraArguments)
{
if (parameters.Any())
{
_writer.WriteSymbol(",");
}
_writer.WriteSpace();
_writer.Write("__arglist");
}
WriteSymbol(end);
}
public JsonResult GetApplication(byte?id)
{
return(new JsonResult {
Data = _unitOfWork.ApplicationRepository.GetByID(id).ToApplicationView()
});
}
/// <summary>
///
/// Set AntDeviceType subfield</summary>
/// <param name="antDeviceType">Subfield value to be set</param>
public void SetAntDeviceType(byte?antDeviceType)
{
SetFieldValue(1, 0, antDeviceType, DeviceTypeSubfield.AntDeviceType);
}
/// <summary>
/// Получает класс цвета для грида по коду типа транзакции.
/// </summary>
/// <param name="transactionKindID">Код транзакции.</param>
/// <returns>Название класса.</returns>
public static string GetTransactionKindRowClass(byte?transactionKindID)
{
return(transactionKindID == TransactionKindSet.Revenue.TransactionKindID ? GridRowColors.Success : GridRowColors.Warning);
}
/// <summary>
/// Set DeviceIndex field</summary>
/// <param name="deviceIndex_">Nullable field value to be set</param>
public void SetDeviceIndex(byte?deviceIndex_)
{
SetFieldValue(0, 0, deviceIndex_, Fit.SubfieldIndexMainField);
}
private static object CovertFromJTokePrimitiveType(JToken keyValue, Type propertyInfoPropertyType)
{
if (propertyInfoPropertyType == typeof(string))
{
string value = (string)keyValue;
return(value);
}
if (propertyInfoPropertyType == typeof(int) || propertyInfoPropertyType.IsEnum)
{
int value = (int)keyValue;
return(value);
}
if (propertyInfoPropertyType == typeof(bool))
{
bool value = (bool)keyValue;
return(value);
}
if (propertyInfoPropertyType == typeof(DateTimeOffset))
{
DateTimeOffset value = (DateTimeOffset)keyValue;
return(value);
}
if (propertyInfoPropertyType == typeof(bool?))
{
bool?value = (bool?)keyValue;
return(value);
}
if (propertyInfoPropertyType == typeof(long))
{
long value = (long)keyValue;
return(value);
}
if (propertyInfoPropertyType == typeof(DateTime))
{
DateTime value = (DateTime)keyValue;
return(value);
}
if (propertyInfoPropertyType == typeof(DateTimeOffset?))
{
DateTimeOffset?value = (DateTimeOffset?)keyValue;
return(value);
}
if (propertyInfoPropertyType == typeof(DateTime?))
{
DateTime?value = (DateTime?)keyValue;
return(value);
}
if (propertyInfoPropertyType == typeof(decimal?))
{
decimal?value = (decimal?)keyValue;
return(value);
}
if (propertyInfoPropertyType == typeof(double?))
{
double?value = (double?)keyValue;
return(value);
}
if (propertyInfoPropertyType == typeof(char?))
{
char?value = (char?)keyValue;
return(value);
}
if (propertyInfoPropertyType == typeof(short))
{
short value = (short)keyValue;
return(value);
}
if (propertyInfoPropertyType == typeof(ushort))
{
ushort value = (ushort)keyValue;
return(value);
}
if (propertyInfoPropertyType == typeof(char))
{
char value = (char)keyValue;
return(value);
}
if (propertyInfoPropertyType == typeof(byte))
{
byte value = (byte)keyValue;
return(value);
}
if (propertyInfoPropertyType == typeof(int?))
{
int?value = (int?)keyValue;
return(value);
}
if (propertyInfoPropertyType == typeof(short?))
{
short?value = (short?)keyValue;
return(value);
}
if (propertyInfoPropertyType == typeof(ushort?))
{
ushort?value = (ushort?)keyValue;
return(value);
}
if (propertyInfoPropertyType == typeof(byte?))
{
byte?value = (byte?)keyValue;
return(value);
}
if (propertyInfoPropertyType == typeof(long?))
{
long?value = (long?)keyValue;
return(value);
}
if (propertyInfoPropertyType == typeof(float?))
{
float?value = (float?)keyValue;
return(value);
}
if (propertyInfoPropertyType == typeof(decimal))
{
decimal value = (decimal)keyValue;
return(value);
}
if (propertyInfoPropertyType == typeof(uint?))
{
uint?value = (uint?)keyValue;
return(value);
}
if (propertyInfoPropertyType == typeof(ulong?))
{
ulong?value = (ulong?)keyValue;
return(value);
}
if (propertyInfoPropertyType == typeof(double))
{
double value = (double)keyValue;
return(value);
}
if (propertyInfoPropertyType == typeof(float))
{
float value = (float)keyValue;
return(value);
}
if (propertyInfoPropertyType == typeof(uint))
{
uint value = (uint)keyValue;
return(value);
}
if (propertyInfoPropertyType == typeof(ulong))
{
ulong value = (ulong)keyValue;
return(value);
}
if (propertyInfoPropertyType == typeof(byte[]))
{
byte[] value = (byte[])keyValue;
return(value);
}
if (propertyInfoPropertyType == typeof(Guid))
{
Guid value = (Guid)keyValue;
return(value);
}
if (propertyInfoPropertyType == typeof(Guid?))
{
Guid?value = (Guid?)keyValue;
return(value);
}
if (propertyInfoPropertyType == typeof(TimeSpan?))
{
TimeSpan?value = (TimeSpan?)keyValue;
return(value);
}
if (propertyInfoPropertyType == typeof(TimeSpan))
{
TimeSpan value = (TimeSpan)keyValue;
return(value);
}
if (propertyInfoPropertyType == typeof(Uri))
{
Uri value = (Uri)keyValue;
return(value);
}
return(null);
}
public void WriteTypeDeclaration(ITypeDefinition type)
{
INamedTypeDefinition namedType = (INamedTypeDefinition)type;
WriteAttributes(type.Attributes);
WriteAttributes(type.SecurityAttributes);
//TODO: We should likely add support for the SerializableAttribute something like:
// if (type.IsSerializable) WriteFakeAttribute("System.Serializable");
// But we need also consider if this attribute is filtered out or not but I guess
// we have the same problem with all the fake attributes at this point.
if ((type.IsStruct || type.IsClass) && type.Layout != LayoutKind.Auto)
{
FakeCustomAttribute structLayout = new FakeCustomAttribute("System.Runtime.InteropServices", "StructLayoutAttribute");
string layoutKind = string.Format("System.Runtime.InteropServices.LayoutKind.{0}", type.Layout.ToString());
if (_forCompilationIncludeGlobalprefix)
{
layoutKind = "global::" + layoutKind;
}
var args = new List <string>();
args.Add(layoutKind);
if (type.SizeOf != 0)
{
string sizeOf = string.Format("Size={0}", type.SizeOf);
args.Add(sizeOf);
}
if (type.Alignment != 0)
{
string pack = string.Format("Pack={0}", type.Alignment);
args.Add(pack);
}
if (type.StringFormat != StringFormatKind.Ansi)
{
string charset = string.Format("CharSet={0}System.Runtime.InteropServices.CharSet.{1}", _forCompilationIncludeGlobalprefix ? "global::" : "", type.StringFormat);
args.Add(charset);
}
if (IncludeAttribute(structLayout))
{
WriteFakeAttribute(structLayout.FullTypeName, args.ToArray());
}
}
WriteVisibility(TypeHelper.TypeVisibilityAsTypeMemberVisibility(type));
IMethodDefinition invoke = type.GetInvokeMethod();
if (invoke != null)
{
Contract.Assert(type.IsDelegate);
byte?nullableContextValue = invoke.Attributes.GetCustomAttributeArgumentValue <byte?>(CSharpCciExtensions.NullableContextAttributeFullName);
if (invoke.IsMethodUnsafe())
{
WriteKeyword("unsafe");
}
WriteKeyword("delegate");
WriteTypeName(invoke.Type, invoke.ReturnValueAttributes, methodNullableContextValue: nullableContextValue);
WriteIdentifier(namedType.Name);
if (type.IsGeneric)
{
WriteGenericParameters(type.GenericParameters);
}
WriteParameters(invoke.Parameters, invoke.ContainingType, nullableContextValue);
if (type.IsGeneric)
{
WriteGenericContraints(type.GenericParameters, TypeNullableContextValue); // Delegates are special, and the NullableContextValue we should fallback to is the delegate type one, not the invoke method one.
}
WriteSymbol(";");
}
else
{
WriteTypeModifiers(type);
WriteIdentifier(namedType.Name);
Contract.Assert(!(type is IGenericTypeInstance), "Currently don't support generic type instances if we hit this then add support");
if (type.IsGeneric)
{
WriteGenericParameters(type.GenericParameters);
}
WriteBaseTypes(type);
if (type.IsGeneric)
{
WriteGenericContraints(type.GenericParameters);
}
if (type.IsEnum)
{
WriteEnumType(type);
}
}
}
/// <summary>
/// Set HrmAntIdTransType field</summary>
/// <param name="hrmAntIdTransType_">Nullable field value to be set</param>
public void SetHrmAntIdTransType(byte?hrmAntIdTransType_)
{
SetFieldValue(3, 0, hrmAntIdTransType_, Fit.SubfieldIndexMainField);
}
private byte TCPIP_DNS_Q()
{
var flags = cpu.Registers.B;
if (flags.GetBit(2) == 1 && dnsQueryInProgress)
{
return(ERR_QUERY_EXISTS);
}
if (flags.GetBit(0) == 1)
{
dnsQueryInProgress = false;
lastDnsError = 0;
return(ERR_OK);
}
if (NoNetworkAvailable())
{
return(ERR_NO_NETWORK);
}
if (!dnsServersAvailable)
{
return(ERR_NO_DNS);
}
var namePointer = cpu.Registers.HL;
var nameBytes = new List <byte>();
while (slots[namePointer] != 0)
{
nameBytes.Add(slots[namePointer++]);
}
var name = Encoding.ASCII.GetString(nameBytes.ToArray());
var wasIp = IPAddress.TryParse(name, out IPAddress parsedIp) &&
IsIPv4(parsedIp);
if (wasIp)
{
lastIpResolved = parsedIp.GetAddressBytes();
lastIpResolvedWasDirectIp = true;
cpu.Registers.B = 1;
cpu.Registers.L = lastIpResolved[0];
cpu.Registers.H = lastIpResolved[1];
cpu.Registers.E = lastIpResolved[2];
cpu.Registers.D = lastIpResolved[3];
return(ERR_OK);
}
if (flags.GetBit(1) == 1)
{
return(ERR_INV_IP);
}
dnsQueryInProgress = true;
Dns.BeginGetHostAddresses(name,
ar =>
{
dnsQueryInProgress = false;
IPAddress[] addresses;
try
{
addresses = Dns.EndGetHostAddresses(ar);
}
catch (Exception ex)
{
if (ex is SocketException sockEx)
{
lastDnsError = UnapiDnsErrorFromSocketError(sockEx.SocketErrorCode);
}
else
{
lastDnsError = 0;
}
return;
}
var address = addresses.FirstOrDefault(IsIPv4);
lastIpResolved = address?.GetAddressBytes();
lastIpResolvedWasDirectIp = false;
lastDnsError = null;
}
, null);
cpu.Registers.B = 0;
return(ERR_OK);
}
private void SendDeviceCommand(DeviceCommand aDeviceCommand, bool aSecondPS2Port, byte?aByte = null)
{
mDebugger.SendInternal("(PS/2 Controller) Sending device command:");
mDebugger.SendInternal("Device command:");
mDebugger.SendInternal((byte)aDeviceCommand);
if (aSecondPS2Port)
{
SendCommand(Command.WriteNextByteToSecondPS2PortInputBuffer);
}
WaitToWrite();
IO.Data.Byte = (byte)aDeviceCommand;
WaitForAck();
mDebugger.SendInternal("Device command sent.");
if (aByte.HasValue)
{
mDebugger.SendInternal("(PS/2 Controller) Sending byte after device command:");
mDebugger.SendInternal("Byte value:");
mDebugger.SendInternal(aByte.Value);
if (aSecondPS2Port)
{
SendCommand(Command.WriteNextByteToSecondPS2PortInputBuffer);
}
WaitToWrite();
IO.Data.Byte = aByte.Value;
WaitForAck();
}
}
/// <summary>
/// Set ConceptCount field</summary>
/// <param name="conceptCount_">Nullable field value to be set</param>
public void SetConceptCount(byte?conceptCount_)
{
SetFieldValue(3, 0, conceptCount_, Fit.SubfieldIndexMainField);
}
/// <summary>
/// Set AntTransmissionType field</summary>
/// <param name="antTransmissionType_">Nullable field value to be set</param>
public void SetAntTransmissionType(byte?antTransmissionType_)
{
SetFieldValue(20, 0, antTransmissionType_, Fit.SubfieldIndexMainField);
}
/// <summary>
/// Set FieldId field</summary>
/// <param name="fieldId_">Nullable field value to be set</param>
public void SetFieldId(byte?fieldId_)
{
SetFieldValue(2, 0, fieldId_, Fit.SubfieldIndexMainField);
}
/// <summary>
/// Set BatteryStatus field</summary>
/// <param name="batteryStatus_">Nullable field value to be set</param>
public void SetBatteryStatus(byte?batteryStatus_)
{
SetFieldValue(11, 0, batteryStatus_, Fit.SubfieldIndexMainField);
}
public void SetControl(int index, byte?value)
{
}
/// <summary>
/// Set HardwareVersion field</summary>
/// <param name="hardwareVersion_">Nullable field value to be set</param>
public void SetHardwareVersion(byte?hardwareVersion_)
{
SetFieldValue(6, 0, hardwareVersion_, Fit.SubfieldIndexMainField);
}
private void WriteParameter(IParameterDefinition parameter, ITypeReference containingType, bool extensionMethod, byte?methodNullableContextValue)
{
WriteAttributes(parameter.Attributes, true);
if (extensionMethod)
{
WriteKeyword("this");
}
if (parameter.IsParameterArray)
{
WriteKeyword("params");
}
if (parameter.IsOut && !parameter.IsIn && parameter.IsByReference)
{
WriteKeyword("out");
}
else
{
// For In/Out we should not emit them until we find a scenario that is needs them.
//if (parameter.IsIn)
// WriteFakeAttribute("System.Runtime.InteropServices.In", writeInline: true);
//if (parameter.IsOut)
// WriteFakeAttribute("System.Runtime.InteropServices.Out", writeInline: true);
if (parameter.IsByReference)
{
if (parameter.Attributes.HasIsReadOnlyAttribute())
{
WriteKeyword("in");
}
else
{
WriteKeyword("ref");
}
}
}
WriteTypeName(parameter.Type, containingType, parameter.Attributes, methodNullableContextValue);
WriteIdentifier(parameter.Name);
if (parameter.IsOptional && parameter.HasDefaultValue)
{
WriteSymbol(" = ");
WriteMetadataConstant(parameter.DefaultValue, parameter.Type);
}
}
/// <summary>
/// 获取byte?参数，默认defaultValue
/// </summary>
/// <param name="name">参数名</param>
/// <param name="defaultValue">默认值</param>
/// <returns>参数值</returns>
public static byte?GetByteNull(string name, byte?defaultValue)
{
return(XCLNetTools.Common.DataTypeConvert.ToByteNull(FormHelper.GetString(name), defaultValue));
}
