/// <summary> /// Create a packet that will send a custom object creation call. /// It is expected that the first byte that follows will identify which function will be parsing this packet later. /// </summary> static public void CreateEx(int rccID, bool persistent, GameObject go, params object[] objs) { if (go != null) { int index = IndexOf(go); if (isConnected) { if (index != -1) { BinaryWriter writer = mInstance.mClient.BeginSend(Packet.RequestCreate); writer.Write((ushort)index); writer.Write(GetFlag(go, persistent)); writer.Write((byte)rccID); writer.WriteArray(objs); EndSend(); return; } else { Debug.LogError("\"" + go.name + "\" has not been added to TNManager's list of objects, so it cannot be instantiated.\n" + "Consider placing it into the Resources folder and passing its name instead.", go); } } objs = BinaryExtensions.CombineArrays(go, objs); UnityTools.ExecuteAll(GetRCCs(), (byte)rccID, objs); UnityTools.Clear(objs); } }
/// <summary> /// Calculate <c>QR</c> code format /// </summary> /// <param name="error"> /// The error code information. /// </param> /// <param name="mask"> /// The mask. /// </param> private void CalculateFormat(QrError error, QrMask mask) { // Get error bits if (this.debugData != null) { this.debugData.Append("- Calculating format bits...\n"); } // Get 5 bits of format information int formatInfo = (QrErrorBits.GetBits(error) << 3) | BinaryExtensions.BinToDec(mask.GetBits()); if (this.debugData != null) { this.debugData.Append( "- Format information error and mask bits: " + BinaryExtensions.BinaryToString(BinaryExtensions.DecToBin(formatInfo)) + "\n"); this.debugData.Append("- Calculating BCH (15,5) code for information bits...\n"); } int bchCode = QrBoseChaudhuriHocquenghem.CalculateBch(formatInfo, QrConst.GenPolyFormat); if (this.debugData != null) { this.debugData.Append( "- BCH (15,5) error code: " + BinaryExtensions.BinaryToString(BinaryExtensions.DecToBin(bchCode)) + "\n"); } // Append BCH code to format info formatInfo = (formatInfo << 10) | bchCode; if (this.debugData != null) { this.debugData.Append( "- Format information with appended BCH: " + BinaryExtensions.BinaryToString(BinaryExtensions.DecToBin(formatInfo)) + "\n"); this.debugData.Append( "- Calculating XOR with format constant: " + BinaryExtensions.BinaryToString(BinaryExtensions.DecToBin(QrConst.ConstFormatXor)) + "\n"); } formatInfo = formatInfo ^ QrConst.ConstFormatXor; if (this.debugData != null) { this.debugData.Append( "- Final format: " + BinaryExtensions.BinaryToString(BinaryExtensions.DecToBin(formatInfo, 15)) + "\n"); } List <bool> formatBits = BinaryExtensions.DecToBin(formatInfo, 15); // Reverse, because our QRCode is inserting backwards formatBits.Reverse(); foreach (bool t in formatBits) { this.output.Enqueue(t); } }
/// <summary> /// Serializes a Message to a Sachiel buffer and sets the Raw property. /// If you are attempting to serialize a request endpoint, set includeEndpointAsHeader to true to automatically set the header. /// </summary> /// <returns></returns> public async Task <byte[]> Serialize(int allocate = 0, bool includeEndpointAsHeader = false) { var messageStream = new MemoryStream(allocate); var headerStream = new MemoryStream(); try { if (!IsCompatibile(Source.GetType())) throw new InvalidSerializationException($"{Source.GetType()} is not based on Message."); } // For IPC purposes people might wish to use request both ways, this should allow them to do that. if (includeEndpointAsHeader) { var attribute = Source.GetType().GetTypeInfo().GetCustomAttribute <SachielEndpoint>(false); if (attribute == null) { throw new InvalidOperationException("No SachielEndpoint attribute is present on message."); } Header.Endpoint = attribute?.Name; } //Throw is the header is null. if (string.IsNullOrEmpty(Header?.Endpoint)) { throw new InvalidOperationException("Message headers cannot be null."); } Serialize(ref headerStream, Target.Header); await UnsafeArrayIo.WriteArray(messageStream, BinaryExtensions.EncodeVariableLengthQuantity((ulong)headerStream.Length), true); await UnsafeArrayIo.WriteArray(messageStream, headerStream.ToArray(), true); Serialize(ref messageStream, Target.Source); return(messageStream.ToArray()); }
/// <summary> /// Read page bytes from disk /// </summary> public virtual byte[] ReadPage(uint pageID) { var buffer = new byte[BasePage.PAGE_SIZE]; var position = BasePage.GetSizeOfPages(pageID); // position cursor if (_stream.Position != position) { _stream.Seek(position, SeekOrigin.Begin); } // read bytes from data file _stream.Read(buffer, 0, BasePage.PAGE_SIZE); // when reading the header, check the password if (pageID == 0 && _crypto != null) { // I know, header page will be double read (it's the price for isolated concerns) var header = (HeaderPage)BasePage.ReadPage(buffer); if (BinaryExtensions.BinaryCompareTo(_password, header.Password) != 0) { throw LiteException.DatabaseWrongPassword(); } } else if (_crypto != null) { buffer = _crypto.Decrypt(buffer); } return(buffer); }
public void AddBinaryNull_Should_NotAddLogEventDetail() { var logEvent = new LogEvent <StandardLoglevel>(_ => { }, StandardLoglevel.Warning); BinaryExtensions.Binary <StandardLoglevel>(logEvent, null).Should().BeSameAs(logEvent); logEvent.Details.OfType <Binary>().Any().Should().BeFalse(); }
/// <summary> /// Create a packet that will send a custom object creation call. /// It is expected that the first byte that follows will identify which function will be parsing this packet later. /// </summary> static public void CreateEx(int rccID, bool persistent, string path, params object[] objs) { GameObject go = LoadGameObject(path); if (go != null) { if (isConnected) { if (mInstance != null && mInstance.mClient.isSwitchingScenes) { Debug.LogWarning("Trying to create an object while switching scenes. Call will be ignored."); } BinaryWriter writer = mInstance.mClient.BeginSend(Packet.RequestCreate); byte flag = GetFlag(go, persistent); writer.Write((ushort)65535); writer.Write(flag); writer.Write(path); writer.Write((byte)rccID); writer.WriteArray(objs); EndSend(); return; } objs = BinaryExtensions.CombineArrays(go, objs); UnityTools.ExecuteAll(GetRCCs(), (byte)rccID, objs); UnityTools.Clear(objs); } else { Debug.LogError("Unable to load " + path); } }
public void AddBinaryData_Should_AddLogEventDetail() { var data = new byte[] { 48, 49, 50, 51 }; var logEvent = new LogEvent <StandardLoglevel>(_ => { }, StandardLoglevel.Warning); BinaryExtensions.Binary <StandardLoglevel>(logEvent, data).Should().BeSameAs(logEvent); logEvent.Details.OfType <Binary>().Single().Data.SequenceEqual(data).Should().BeTrue(); }
public void Deserialize(BEReader br) { Header.Deserialize(br); Payload = CreateFromPayloadType(Header.PayloadType); byte[] buf = br.ReadToEnd(); BinaryReader payloadReader = BinaryExtensions.ReaderFromBytes(buf); Payload.Deserialize(payloadReader); }
public void GetByteLengthTest() { int i1 = 0; int i2 = 0; Assert.AreEqual(8, BinaryExtensions.GetByteLength(i1, i2)); short s1 = 0; Assert.AreEqual(10, BinaryExtensions.GetByteLength(i1, i2, s1)); long l1 = 0; Assert.AreEqual(18, BinaryExtensions.GetByteLength(i1, i2, s1, l1)); }
public static ulong?GetNullableUnsignedLong(IDataRecord reader, int index) { if (reader.IsDBNull(index)) { return(default(ulong?)); } var value = reader.GetValue(index); var bytes = (byte[])value; if (bytes.Length == 0) { return(default(ulong?)); } return(BinaryExtensions.RowVersionBytesToUInt64(bytes)); }
private byte[] ReadAndDecryptChunk(Stream stream) { var reader = new BEReader(stream); // 0xde, 0xad reader.ReadBytes(2); var length = reader.ReadUInt16(); var encryptedPayloadLength = length + BinaryExtensions.CalculatePaddingSize(length, 16); var encryptedPayloadBytes = new byte[encryptedPayloadLength]; var encryptedPayloadPosition = 0; while (encryptedPayloadPosition < encryptedPayloadLength - 1) { var received = reader.ReadBytes(encryptedPayloadLength - encryptedPayloadPosition); received.CopyTo(encryptedPayloadBytes, encryptedPayloadPosition); encryptedPayloadPosition += received.Length; } var signature = reader.ReadBytes(32); var bodyWriter = new BEWriter(); bodyWriter.Write(new byte[] { 0xde, 0xad }); bodyWriter.Write(length); bodyWriter.Write(encryptedPayloadBytes); var messageSignature = _cryptoContext.CalculateMessageSignature(bodyWriter.ToArray()); if (!signature.SequenceEqual(messageSignature)) { throw new InvalidDataException("Invalid message signature."); } var decryptedPayload = _cryptoContext.Decrypt(encryptedPayloadBytes); return(decryptedPayload.Take(length).ToArray()); }
/// <summary> /// The do mask. /// </summary> /// <param name="codeMask"> /// The mask. /// </param> private void DoMask(QrMask codeMask) { if (this.debugData != null) { this.debugData.Append( "------------------ Step 9 ------------------\n- Executing mask on data pixels: " + BinaryExtensions.BinaryToString(codeMask.GetBits()) + "\n"); } int counter = 0; for (int i = 0; i < this.picture.GetLength(0); i++) { for (int j = 0; j < this.picture.GetLength(1); j++) { int x = this.picture.GetLength(0) - i - 1; int y = this.picture.GetLength(1) - j - 1; if (codeMask.Test(y, x) && (this.staticData[x, y] == false) && (this.picture[x, y] != QrPixel.Empty)) { this.picture[x, y] = (this.picture[x, y] == QrPixel.White) ? QrPixel.Black : QrPixel.White; counter++; if ((this.breakPoint == QrBreakPoint.Mask) && (this.debugData != null)) { this.picture[x, y] = QrPixel.Mask; } } } } if (this.debugData != null) { this.debugData.Append("- Mask (" + codeMask + ") written to: " + counter + " pixels.\n\n"); } }
public void FromBinaryNullStringTest() { Action act = () => BinaryExtensions.FromBinary <SerializableObjectFake>(null); act.Should().Throw <ArgumentNullException>(); }
public void LogEventNull_ShouldThrow_ArgumentNullException() { Assert.Throws <ArgumentNullException>(() => BinaryExtensions.Binary <StandardLoglevel>(null, new byte[] { 0x00, 0x01, 0x02, 0x03 })); }
/// <summary> /// The process. /// </summary> /// <exception cref="ArgumentException"> /// Throws argument exception if wrong type or version are selected /// </exception> /// <exception cref="Exception"> /// Throws exception if text is too long for the matrix /// </exception> private void Process() { // Preprocess // -> one of the parameters was not set, simple mode // -> create structure of QR Image this.ChooseVersions(); if (this.debugData != null) { this.img = new QrImage(this.version, this.mask, this.breakPoint); this.debugData.Append(this.img.GetDebugData()); } else { this.img = new QrImage(this.version, this.mask); } if ((this.breakPoint == QrBreakPoint.CreatedMatrix) && (this.debugData != null)) { this.debugData.Append("------- Breakpoint reached: Step 1 -------"); return; } // Step one - sending type to output if (this.debugData != null) { this.debugData.Append( "------------------ Step 1 ------------------\n- Sending type bits (4) to output ...\n"); } switch (this.type) { case QrType.Numeric: this.output.Enqueue(false); this.output.Enqueue(false); this.output.Enqueue(false); this.output.Enqueue(true); break; case QrType.AlphaNumeric: this.output.Enqueue(false); this.output.Enqueue(false); this.output.Enqueue(true); this.output.Enqueue(false); break; case QrType.Binary: this.output.Enqueue(false); this.output.Enqueue(true); this.output.Enqueue(false); this.output.Enqueue(false); break; case QrType.Japanese: this.output.Enqueue(true); this.output.Enqueue(false); this.output.Enqueue(false); this.output.Enqueue(false); break; default: throw new ArgumentException("Wrong QRType selected."); } if (this.debugData != null) { this.debugData.Append( "- Sent 4 bytes of output: " + BinaryExtensions.BinaryToString(this.output) + "\n\n"); } if ((this.breakPoint == QrBreakPoint.OutputTypeBits) && (this.debugData != null)) { this.debugData.Append("------- Breakpoint reached: Step 2 -------"); return; } // Step two - write length of string if (this.debugData != null) { this.debugData.Append( "------------------ Step 2 ------------------\n- Calculating bit size for data length ...\n"); } byte strLength; if ((this.version.Version >= 1) && (this.version.Version <= 9)) { switch (this.type) { case QrType.Numeric: strLength = 10; break; case QrType.AlphaNumeric: strLength = 9; break; case QrType.Binary: strLength = 8; break; case QrType.Japanese: strLength = 8; break; default: strLength = 0; break; } } else if ((this.version.Version >= 10) && (this.version.Version <= 26)) { switch (this.type) { case QrType.Numeric: strLength = 12; break; case QrType.AlphaNumeric: strLength = 11; break; case QrType.Binary: strLength = 16; break; case QrType.Japanese: strLength = 10; break; default: strLength = 0; break; } } else if ((this.version.Version >= 27) && (this.version.Version <= 40)) { switch (this.type) { case QrType.Numeric: strLength = 14; break; case QrType.AlphaNumeric: strLength = 13; break; case QrType.Binary: strLength = 16; break; case QrType.Japanese: strLength = 12; break; default: strLength = 0; break; } } else { throw new ArgumentException("Wrong QRVersion selected."); } if (this.debugData != null) { this.debugData.Append( "- QR Type: " + this.type + ", QR Version: " + this.version.Version + ", Bit size: " + strLength + " bits.\n"); } // Write length to output int length = this.text.Length; this.ToOutput(BinaryExtensions.DecToBin(length, strLength)); if (this.debugData != null) { this.debugData.Append( "- Stored data length to output: " + BinaryExtensions.BinaryToString(BinaryExtensions.DecToBin(length, strLength)) + "\n"); this.debugData.Append( "- Data stored in output: " + BinaryExtensions.BinaryToString(this.output) + "\n\n"); } if ((this.breakPoint == QrBreakPoint.OutputDataLength) && (this.debugData != null)) { this.debugData.Append("------- Breakpoint reached: Step 3 -------"); return; } // Step 3 - encoding entry text if (this.debugData != null) { this.debugData.Append( "------------------ Step 3 ------------------\n- Creating code table for input ...\n"); } QrCodeTable table = new QrCodeTable(this.type); if (this.debugData != null) { this.debugData.Append("- Checking for odd input length.\n"); } // Odd text length handling if (length % 2 == 1) { if (this.debugData != null) { this.debugData.Append(" - Text length is odd, reducing size for one character.\n"); } length = length - 1; } if (this.debugData != null) { this.debugData.Append("- Writing characters ...\n"); } for (int i = 0; i < length; i += 2) { // Get number int calc = (table.GetCharCount() * table.GetCodeByChar(this.text[i])) + table.GetCodeByChar(this.text[i + 1]); if (this.debugData != null) { this.debugData.Append( " - Characters: " + this.text[i] + ", " + this.text[i + 1] + ": (" + table.GetCharCount() + " * " + table.GetCodeByChar(this.text[i]) + ") + " + table.GetCodeByChar(this.text[i + 1]) + " = " + calc + "\n"); } // Write number, why 11 bits for each sign????? // Experimental: strLength as calculated for size. this.ToOutput(BinaryExtensions.DecToBin(calc, 11)); } // Handling last 6 bits for odd length if (this.text.Length % 2 == 1) { if (this.debugData != null) { this.debugData.Append( "- Writing last (odd) character " + this.text[this.text.Length - 1] + " with " + 6 + " bits: " + table.GetCodeByChar(this.text[this.text.Length - 1]) + "\n"); } this.ToOutput(BinaryExtensions.DecToBin(table.GetCodeByChar(this.text[this.text.Length - 1]), 6)); } if (this.debugData != null) { this.debugData.Append("- Input successfully encoded to binary.\n\n"); } if ((this.breakPoint == QrBreakPoint.EncodedDataToBinary) && (this.debugData != null)) { this.debugData.Append("------- Breakpoint reached: Step 4 -------"); return; } // Step 4 - finishing binary string if (this.debugData != null) { this.debugData.Append("------------------ Step 4 ------------------\n- Finishing binary string ...\n"); } // Calculate maximum bit length int maxBits = this.version.DataSize * 8; if (this.debugData != null) { this.debugData.Append( "- Maximum bits for current version: " + maxBits + " current bits: " + this.output.Count + "\n"); } // Add zeros to end of bit string, if we are missing them int bitOverflow = 0; while (this.output.Count < maxBits) { this.output.Enqueue(false); bitOverflow++; if (bitOverflow >= 4) { break; } } if (this.debugData != null) { this.debugData.Append( "- Added " + bitOverflow + " bits to binary output. Total: " + this.output.Count + " bits.\n\n"); } if ((this.breakPoint == QrBreakPoint.FinishedBinary) && (this.debugData != null)) { this.debugData.Append("------- Breakpoint reached: Step 5 -------"); return; } // Step 5 - breaking the bit string into bytes if (this.debugData != null) { this.debugData.Append( "------------------ Step 5 ------------------\n- Dividing bits into bytes (8 bits per byte) ...\n"); this.debugData.Append("- Current output size: " + this.output.Count + " bits\n"); } // For now we will just make sure it is divided by 8, we will not convert to bytes unless required. while (this.output.Count % 8 != 0) { this.output.Enqueue(false); } if (this.debugData != null) { this.debugData.Append( "- Added zeros to output, current size: " + this.output.Count + " bits, " + (this.output.Count / 8) + " bytes.\n\n"); } if ((this.breakPoint == QrBreakPoint.BrokenBinary) && (this.debugData != null)) { this.debugData.Append("------- Breakpoint reached: Step 6 -------"); return; } // Step 6 - inserting characters if (this.debugData != null) { this.debugData.Append( "------------------ Step 6 ------------------\n- Inserting characters to fill missing data string ...\n"); } // If we have too many bits if ((this.output.Count / 8) > this.version.DataSize) { throw new Exception("Text is too long for current matrix."); } // If we have less or exact number of bits List <bool> defaultBlock1 = BinaryExtensions.DecToBin(236, 8); List <bool> defaultBlock2 = BinaryExtensions.DecToBin(17, 8); // Fill matrix until it is full as specified in version int fillCount = 0; if (this.debugData != null) { this.debugData.Append( "- Current output size: " + (this.output.Count / 8) + ", missing: " + (this.version.DataSize - (this.output.Count / 8)) + " bytes.\n"); this.debugData.Append("- Added bytes: "); } while ((this.output.Count / 8) < this.version.DataSize) { if ((fillCount % 2) == 0) { if (this.debugData != null) { this.debugData.Append("236, "); } this.ToOutput(defaultBlock1); } else { if (this.debugData != null) { this.debugData.Append("17, "); } this.ToOutput(defaultBlock2); } fillCount++; } if (this.debugData != null) { this.debugData.Append( "\n- Output size filled to match data size: " + (this.output.Count / 8) + "/" + this.version.DataSize + " bytes\n\n"); } if ((this.breakPoint == QrBreakPoint.MissingBytes) && (this.debugData != null)) { this.debugData.Append("------- Breakpoint reached: Step 7 -------"); return; } // Step 7 - generating error code correction (ECC) by Reed-Solomon procedure // Convert bits from output to byte array byte[] bytes = BinaryExtensions.BitArrayToByteArray(new BitArray(this.output.ToArray())); if (this.debugData != null) { this.debugData.Append( "------------------ Step 7 ------------------\n- Calculating error code correction ...\n"); this.debugData.Append( "- Dividing data words into blocks: " + this.version.GetBlockCount() + " total.\n"); this.debugData.Append("- Creating message polynomial for each block ...\n"); } // Divide bytes into blocks QrBlock[] blocks = new QrBlock[this.version.GetBlockCount()]; for (int x = 0; x < this.version.GetBlockCount(); x++) { // Creating message polynominal system (F(x)) for current block // Calculate block length and starting position int blockLength; int blockStart; if (x >= this.version.BlockOneCount) { blockLength = this.version.BlockTwoSize; blockStart = (this.version.BlockOneSize * this.version.BlockOneCount) + ((x - this.version.BlockOneCount) * this.version.BlockTwoSize); } else { blockLength = this.version.BlockOneSize; blockStart = this.version.BlockOneSize * x; } if (this.debugData != null) { this.debugData.Append( "----------------------------------\n- Block " + (x + 1) + ", data from: " + blockStart + ", length: " + blockLength + "\n- Message polynomial:\n\n"); } Poly message = new Poly(); int messageLevel = this.version.BlockOneSize + (this.version.ErrorSize / this.version.GetBlockCount()) - 1; for (int i = 0; i < blockLength; i++) { if (this.debugData != null) { this.debugData.Append("(" + bytes[i + blockStart] + "x ^ " + messageLevel + ")"); if (i != blockLength - 1) { this.debugData.Append(" + "); } } Term ter = new Term(messageLevel, bytes[i + blockStart]); message.Terms.Add(ter); messageLevel--; } if (this.debugData != null) { this.debugData.Append( "\n\n- Calculating " + ((int)Math.Floor(this.version.ErrorSize / (double)this.version.GetBlockCount())) + " error codes using Reed-Solomon algorithm.\n"); } // Calculate Error codes of desired block blocks[x] = new QrBlock { MessagePoly = new Poly(message) }; // Create Reed Solomon algorithm class QrReedSolomon ecc = new QrReedSolomon(); // Experimental bugfix: rounding the result, so we can choose correct ECC blocks[x].EccCoefficients = ecc.Calculate( message, (int)Math.Floor(this.version.ErrorSize / (double)this.version.GetBlockCount())); if (this.debugData != null) { this.debugData.Append( "- Calculated error codes: " + BinaryExtensions.ArrayToString(blocks[x].EccCoefficients) + "\n\n"); } } // Write error codes to bit stream // Clear current output this.output.Clear(); // Writing data bits if (this.debugData != null) { this.debugData.Append("- Writing data bits into output:\n- "); } // Blocks might not be the same size... for (int i = 0; i < Math.Max(this.version.BlockOneSize, this.version.BlockTwoSize); i++) { foreach (QrBlock t in blocks) { if (i < t.MessagePoly.Terms.Length) { this.ToOutput(BinaryExtensions.DecToBin(t.MessagePoly.Terms[i].Coefficient, 8)); if (this.debugData != null) { this.debugData.Append(t.MessagePoly.Terms[i].Coefficient + ", "); } } } } if (this.debugData != null) { this.debugData.Append("\n\n- Writing ECC bits to output:\n- "); } // Writting ECC bits for (int i = 0; i < blocks[0].EccCoefficients.Length; i++) { if (i == 17) { if (this.debugData != null) { this.debugData.Append(","); } } foreach (QrBlock t in blocks) { this.ToOutput(BinaryExtensions.DecToBin(t.EccCoefficients[i], 8)); if (this.debugData != null) { this.debugData.Append(t.EccCoefficients[i] + ", "); } } } if (this.debugData != null) { this.debugData.Append("\n\n"); } // Step 8, 9, 10 - Handled by QRImage class if ((this.breakPoint == QrBreakPoint.ErrorCode) && (this.debugData != null)) { this.debugData.Append("------- Breakpoint reached: Step 8 -------"); return; } this.img.CreateImage(this.output); if (this.debugData != null) { this.debugData.Append(this.img.GetDebugData()); } }
/// <summary> /// The write version. /// </summary> /// <param name="codeVersion"> /// The version. /// </param> private void WriteVersion(QrVersion codeVersion) { if (this.debugData != null) { this.debugData.Append("- Should we write version information bits?\n"); } // Only writing version with versions higher than 6 if (codeVersion.Version >= 7) { // Calculate BCH (18, 6) for version information int bchVersion = QrBoseChaudhuriHocquenghem.CalculateBch(codeVersion.Version, QrConst.GenPolyVersion); int versionInformation = (codeVersion.Version << 12) | bchVersion; List <bool> versionInfo = BinaryExtensions.DecToBin(versionInformation, 18); versionInfo.Reverse(); if (this.debugData != null) { this.debugData.Append( "- Yes, writing information: " + BinaryExtensions.BinaryToString(versionInfo) + ".\n"); } int iterator = 0; // Version bits at upper right corner for (int y = 0; y < 6; y++) { for (int x = this.picture.GetLength(0) - 8 - 3, j = 0; j < 3; x++, j++) { this.picture[x, y] = versionInfo[iterator] ? QrPixel.Black : QrPixel.White; iterator++; } } iterator = 0; // Version bits at lower left corner for (int x = 0; x < 6; x++) { for (int y = this.picture.GetLength(0) - 8 - 3, j = 0; j < 3; y++, j++) { this.picture[x, y] = versionInfo[iterator] ? QrPixel.Black : QrPixel.White; iterator++; } } if (this.debugData != null) { this.debugData.Append("- Version information bits successfully written.\n"); } } if ((this.debugData != null) && (codeVersion.Version < 7)) { this.debugData.Append("- No, only required for versions higher than 6.\n"); } }
public void ToBinaryNullObjectTest() { Action Act = () => BinaryExtensions.ToBinary <SerializableObjectFake>(null); Act.Should().Throw <ArgumentNullException>(); }
public static ulong GetUnsignedLong(IDataRecord reader, int index) { var value = reader.GetValue(index); return(BinaryExtensions.RowVersionBytesToUInt64((byte[])value)); }
public void DeserializeData(ISerializableLE payloadType) { Data = payloadType; Data.Deserialize(BinaryExtensions.ReaderFromBytes(RawData)); }
public static INanoPacket ParsePacket(byte[] data, NanoChannelContext context) { BEReader packetReader = new BEReader(data); RtpHeader header = new RtpHeader(); header.Deserialize(packetReader); NanoPayloadType payloadType = header.PayloadType; // It might be NanoChannel.Unknown at this point, if ChannelCreate // packet was not processed yet // It gets processed at the end of the function NanoChannel channel = context.GetChannel(header.ChannelId); BinaryReader payloadReader = BinaryExtensions.ReaderFromBytes(packetReader.ReadToEnd()); INanoPacket packet = null; switch (payloadType) { // FIXME: Create from Attribute is broken case NanoPayloadType.UDPHandshake: packet = new UdpHandshake(); break; case NanoPayloadType.ControlHandshake: packet = new ControlHandshake(); break; case NanoPayloadType.ChannelControl: // Read type to pinpoint exact payload ChannelControlType cct = (ChannelControlType)payloadReader.ReadUInt32(); packet = CreateFromChannelControlType(cct); break; case NanoPayloadType.Streamer: packet = CreateFromStreamerHeader(payloadReader, channel); break; default: throw new NanoPackingException( $"Unknown packet type received: {payloadType}"); } if (packet == null) { throw new NanoPackingException("Failed to find matching body for packet"); } payloadReader.Seek(0, SeekOrigin.Begin); packet.Deserialize(payloadReader); packet.Header = header; if (packet as ChannelCreate != null) { string channelName = ((ChannelCreate)packet).Name; channel = NanoChannelClass.GetIdByClassName(channelName); } if (channel == NanoChannel.Unknown) { throw new NanoPackingException("ParsePacket: INanoPacket.Channel is UNKNOWN"); } packet.Channel = channel; return(packet); }