/// <summary> /// This method is used to convert the element of StreamObjectHeaderStart16bit basic object into a byte List. /// </summary> /// <returns>Return the byte list which store the byte information of StreamObjectHeaderStart16bit.</returns> public override List <byte> SerializeToByteList() { BitWriter bitField = new BitWriter(2); bitField.AppendInit32(this.HeaderType, 2); bitField.AppendInit32(this.Compound, 1); bitField.AppendUInit32(Convert.ToUInt32(this.Type), 6); bitField.AppendInit32(this.Length, 7); return(new List <byte>(bitField.Bytes)); }
/// <summary> /// This method is used to convert the element of StreamObjectHeaderEnd16bit basic object into a byte List. /// </summary> /// <returns>Return the byte list which store the byte information of StreamObjectHeaderEnd16bit.</returns> public override List <byte> SerializeToByteList() { BitWriter bitFieldWriter = new BitWriter(2); bitFieldWriter.AppendInit32(0x3, 2); bitFieldWriter.AppendUInit32(Convert.ToUInt32(this.Type), 14); return(new List <byte>(bitFieldWriter.Bytes)); }
/// <summary> /// This method is used to convert the element of StreamObjectHeaderStart32bit basic object into a byte List. /// </summary> /// <returns>Return the byte list which store the byte information of StreamObjectHeaderStart32bit.</returns> public override List <byte> SerializeToByteList() { BitWriter bitFieldWriter = new BitWriter(4); bitFieldWriter.AppendInit32(this.HeaderType, 2); bitFieldWriter.AppendInit32(this.Compound, 1); bitFieldWriter.AppendUInit32(Convert.ToUInt32(this.Type), 14); bitFieldWriter.AppendInit32(this.Length, 15); List <byte> listByte = new List <byte>(bitFieldWriter.Bytes); if (this.LargeLength != null) { listByte.AddRange(this.LargeLength.SerializeToByteList().ToArray()); } return(listByte); }
/// <summary> /// This method is used to convert the element into a byte List /// </summary> /// <returns>Return the Byte List</returns> public override List <byte> SerializeToByteList() { List <byte> byteList = new List <byte>(); byteList.AddRange(base.SerializeToByteList()); byteList.AddRange(this.AllocateExtendedGuidRangeRequest.SerializeToByteList()); byteList.AddRange(this.RequestIDCount.SerializeToByteList()); BitWriter bitWriter = new BitWriter(1); bitWriter.AppendInit32(this.Reserved, 8); List <byte> reservedBytes = new List <byte>(bitWriter.Bytes); byteList.AddRange(reservedBytes); byteList.AddRange(this.ToBytesEnd()); return(byteList); }
/// <summary> /// This method is used to analyze the zip file header. /// </summary> /// <param name="content">Specify the zip content.</param> /// <param name="index">Specify the start position.</param> /// <param name="dataFileSignature">Specify the output value for the data file signature.</param> /// <returns>Return the data file content.</returns> private byte[] AnalyzeFileHeader(byte[] content, int index, out byte[] dataFileSignature) { int crc32 = BitConverter.ToInt32(content, index + 14); int compressedSize = BitConverter.ToInt32(content, index + 18); int uncompressedSize = BitConverter.ToInt32(content, index + 22); int fileNameLength = BitConverter.ToInt16(content, index + 26); int extraFileldLength = BitConverter.ToInt16(content, index + 28); int headerLength = 30 + fileNameLength + extraFileldLength; BitWriter writer = new BitWriter(20); writer.AppendInit32(crc32, 32); writer.AppendUInt64((ulong)compressedSize, 64); writer.AppendUInt64((ulong)uncompressedSize, 64); dataFileSignature = writer.Bytes; return(AdapterHelper.GetBytes(content, index, headerLength)); }
/// <summary> /// This method is used to convert the element into a byte List /// </summary> /// <returns>Return the Byte List</returns> public List <byte> SerializeToByteList() { this.RequestStart = new StreamObjectHeaderStart32bit(StreamObjectTypeHeaderStart.Request, 0); this.UserAgentStart = new StreamObjectHeaderStart32bit(StreamObjectTypeHeaderStart.UserAgent, 0); this.UserAgentGUID = new StreamObjectHeaderStart32bit(StreamObjectTypeHeaderStart.UserAgentGUID, 16); this.UserAgentVersion = new StreamObjectHeaderStart32bit(StreamObjectTypeHeaderStart.UserAgentversion, 4); this.UserAgentEnd = new StreamObjectHeaderEnd16bit((int)StreamObjectTypeHeaderEnd.UserAgent); this.CellRequestEnd = new StreamObjectHeaderEnd16bit((int)StreamObjectTypeHeaderEnd.Request); List <byte> byteList = new List <byte>(); // Protocol Version byteList.AddRange(LittleEndianBitConverter.GetBytes(this.ProtocolVersion)); // Minimum Version byteList.AddRange(LittleEndianBitConverter.GetBytes(this.MinimumVersion)); // Signature byteList.AddRange(LittleEndianBitConverter.GetBytes(this.Signature)); // Request Start byteList.AddRange(this.RequestStart.SerializeToByteList()); // User Agent Start byteList.AddRange(this.UserAgentStart.SerializeToByteList()); // User Agent GUID byteList.AddRange(this.UserAgentGUID.SerializeToByteList()); // GUID byteList.AddRange(this.GUID.ToByteArray()); // User Agent Version byteList.AddRange(this.UserAgentVersion.SerializeToByteList()); // Version byteList.AddRange(LittleEndianBitConverter.GetBytes(this.Version)); // User Agent End byteList.AddRange(this.UserAgentEnd.SerializeToByteList()); if (this.IsRequestHashingOptionsUsed) { List <byte> hashSchemaList = this.RequestHashingSchema.SerializeToByteList(); this.RequestHashingOptionsDeclaration = new StreamObjectHeaderStart32bit(StreamObjectTypeHeaderStart.RequestHashOptions, hashSchemaList.Count + 1); // Request Hashing Options Declaration byteList.AddRange(this.RequestHashingOptionsDeclaration.SerializeToByteList()); // Request Hashing Schema byteList.AddRange(hashSchemaList); // Reserve BitWriter bw = new BitWriter(1); bw.AppendInit32(this.Reserve1, 1); bw.AppendInit32(this.Reserve2, 1); bw.AppendInit32(this.RequestDataElementHashesInsteadofData, 1); bw.AppendInit32(this.RequestDataElementHashes, 1); bw.AppendInit32(this.Reserve3, 4); byteList.AddRange(bw.Bytes); } // Sub-requests if (this.SubRequests != null && this.SubRequests.Count != 0) { foreach (FsshttpbCellSubRequest subRequest in this.SubRequests) { byteList.AddRange(subRequest.SerializeToByteList()); } } else { throw new InvalidOperationException("MUST contain sub request in request structure which is defined in the MS-FSSHTTPB."); } // Data Element Package if (this.DataElementPackage != null) { byteList.AddRange(this.DataElementPackage.SerializeToByteList()); } // Cell Request End byteList.AddRange(this.CellRequestEnd.SerializeToByteList()); return(byteList); }
/// <summary> /// This method is used to convert the element into a byte List /// </summary> /// <returns>Return the Byte List</returns> public override List <byte> SerializeToByteList() { // Storage Index Extended GUID this.StorageIndexExtendedGUID = this.StorageIndexExtendedGUID ?? new ExGuid(); List <byte> storageIndexExtendedGUIDBytes = this.StorageIndexExtendedGUID.SerializeToByteList(); // Expect Storage Index Extended GUID List <byte> expectedStorageIndexExtendedGUIDBytes = this.ExpectedStorageIndexExtendedGUID.SerializeToByteList(); // Put Changes Request this.PutChangesRequestStart = new StreamObjectHeaderStart32bit(StreamObjectTypeHeaderStart.PutChangesRequest, 1 + storageIndexExtendedGUIDBytes.Count + expectedStorageIndexExtendedGUIDBytes.Count); List <byte> putChangesRequestBytes = this.PutChangesRequestStart.SerializeToByteList(); // reserved BitWriter bitWriter = new BitWriter(1); bitWriter.AppendInit32(this.ImplyNullExpectedIfNoMapping, 1); bitWriter.AppendInit32(this.Partial, 1); bitWriter.AppendInit32(this.PartialLast, 1); bitWriter.AppendInit32(this.FavorCoherencyFailureOverNotFound, 1); bitWriter.AppendInit32(this.AbortRemainingPutChangesOnFailure, 1); bitWriter.AppendInit32(this.MultiRequestPutHint, 1); bitWriter.AppendInit32(this.ReturnCompleteKnowledgeIfPossible, 1); bitWriter.AppendInit32(this.LastWriterWinsOnNextChange, 1); List <byte> reservedBytes = new List <byte>(bitWriter.Bytes); List <byte> byteList = new List <byte>(); // sub-request start byteList.AddRange(base.SerializeToByteList()); // put change request byteList.AddRange(putChangesRequestBytes); // Storage Index Extended GUID byteList.AddRange(storageIndexExtendedGUIDBytes); // Expected Storage Index Extended GUID byteList.AddRange(expectedStorageIndexExtendedGUIDBytes); // reserved byteList.AddRange(reservedBytes); if (this.IsAdditionalFlagsUsed) { this.AdditionalFlagsStart = new StreamObjectHeaderStart32bit(StreamObjectTypeHeaderStart.AdditionalFlags, 2); byteList.AddRange(this.AdditionalFlagsStart.SerializeToByteList()); BitWriter additionalFlagsWriter = new BitWriter(2); additionalFlagsWriter.AppendInit32(this.ReturnAppliedStorageIndexIdEntries, 1); additionalFlagsWriter.AppendInit32(this.ReturnDataElementsAdded, 1); additionalFlagsWriter.AppendInit32(this.CheckForIdReuse, 1); additionalFlagsWriter.AppendInit32(this.CoherencyCheckOnlyAppliedIndexEntries, 1); additionalFlagsWriter.AppendInit32(this.FullFileReplacePut, 1); additionalFlagsWriter.AppendInit32(this.RequireStorageMappingsRooted, 1); additionalFlagsWriter.AppendInit32(this.Reserve, 10); byteList.AddRange(additionalFlagsWriter.Bytes); } if (this.IsLockIdUsed) { this.LockIdStart = new StreamObjectHeaderStart32bit(StreamObjectTypeHeaderStart.PutChangesLockId, 16); byteList.AddRange(this.LockIdStart.SerializeToByteList()); byteList.AddRange(this.LockID.ToByteArray()); } if (this.OptionalClientKnowledge != null) { byteList.AddRange(this.OptionalClientKnowledge.SerializeToByteList()); } if (this.IsDiagnosticRequestOptionInputUsed) { this.DiagnosticRequestOptionInputStart = new StreamObjectHeaderStart32bit(StreamObjectTypeHeaderStart.DiagnosticRequestOptionInput, 2); byteList.AddRange(this.DiagnosticRequestOptionInputStart.SerializeToByteList()); BitWriter diagnosticRequestOptionWriter = new BitWriter(2); diagnosticRequestOptionWriter.AppendInit32(this.ForceRevisionChainOptimization, 1); diagnosticRequestOptionWriter.AppendInit32(this.Reserve, 7); byteList.AddRange(diagnosticRequestOptionWriter.Bytes); } // sub-request end byteList.AddRange(this.ToBytesEnd()); return(byteList); }
/// <summary> /// This method is used to convert the element into a byte List /// </summary> /// <returns>Return the Byte List</returns> public override List <byte> SerializeToByteList() { List <byte> byteList = new List <byte>(); byteList.AddRange(base.SerializeToByteList()); // Query Changes Request byteList.AddRange(this.QueryChangesRequest.SerializeToByteList()); // Reserved1 BitWriter bitWriter = new BitWriter(1); bitWriter.AppendInit32(this.Reserved, 1); bitWriter.AppendInit32(this.AllowFragments, 1); bitWriter.AppendInit32(this.ExcludeObjectData, 1); bitWriter.AppendInit32(this.IncludeFilteredOutDataElementsInKnowledge, 1); bitWriter.AppendInit32(this.Reserved1, 4); byteList.AddRange(bitWriter.Bytes); // Cell ID bytes List <byte> cellIDBytes = this.CellId.SerializeToByteList(); // Query Changes Request Arguments this.QueryChangesRequestArguments = new StreamObjectHeaderStart32bit(StreamObjectTypeHeaderStart.QueryChangesRequestArguments, 1 + cellIDBytes.Count); byteList.AddRange(this.QueryChangesRequestArguments.SerializeToByteList()); // Reserved2 bitWriter = new BitWriter(1); bitWriter.AppendInit32(this.IncludeStorageManifest, 1); bitWriter.AppendInit32(this.IncludeCellChanges, 1); bitWriter.AppendInit32(this.Reserved2, 6); byteList.AddRange(bitWriter.Bytes); // Cell ID byteList.AddRange(cellIDBytes); // optional if (this.MaxDataElements != null) { if (this.MaxDataElements.DecodedValue > 0) { // Max Data Elements bytes List <byte> maxDataElementsBytes = (new Compact64bitInt(this.MaxDataElements.DecodedValue)).SerializeToByteList(); // Query Changes Data Constraints this.QueryChangesDataConstraints = new StreamObjectHeaderStart32bit(StreamObjectTypeHeaderStart.QueryChangesDataConstraint, maxDataElementsBytes.Count); byteList.AddRange(this.QueryChangesDataConstraints.SerializeToByteList()); // Max Data Elements byteList.AddRange(maxDataElementsBytes); } } if (this.QueryChangeFilters != null) { foreach (Filter filter in this.QueryChangeFilters) { byteList.AddRange(filter.SerializeToByteList()); } } if (this.Knowledge != null) { byteList.AddRange(this.Knowledge.SerializeToByteList()); } byteList.AddRange(this.ToBytesEnd()); return(byteList); }