public BinaryDocValuesWriter(FieldInfo fieldInfo, Counter iwBytesUsed) { this.FieldInfo = fieldInfo; this.Bytes = new PagedBytes(BLOCK_BITS); this.BytesOut = Bytes.DataOutput; this.Lengths = new AppendingDeltaPackedLongBuffer(PackedInts.COMPACT); this.IwBytesUsed = iwBytesUsed; this.DocsWithField = new FixedBitSet(64); this.BytesUsed = DocsWithFieldBytesUsed(); iwBytesUsed.AddAndGet(BytesUsed); }
/// <summary> /// Encode an exception to an output stream </summary> /// <param name="output"> Data output </param> /// <param name="exception"> Exception to encode </param> /// <exception cref="IOException"> On IO error </exception> //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET: //ORIGINAL LINE: public static void encodeException(DataOutput output, FriendlyException exception) throws IOException public static void encodeException(DataOutput output, FriendlyException exception) { IList <System.Exception> causes = new List <System.Exception>(); System.Exception next = exception.InnerException; while (next != null) { causes.Add(next); next = next.InnerException; } for (int i = causes.Count - 1; i >= 0; i--) { System.Exception cause = causes[i]; output.writeBoolean(true); string message; if (cause is DecodedException) { output.writeUTF(((DecodedException)cause).className); message = ((DecodedException)cause).originalMessage; } else { //JAVA TO C# CONVERTER WARNING: The .NET Type.FullName property will not always yield results identical to the Java Class.getName method: output.writeUTF(cause.GetType().FullName); message = cause.Message; } output.writeBoolean(!string.ReferenceEquals(message, null)); if (!string.ReferenceEquals(message, null)) { output.writeUTF(message); } encodeStackTrace(output, cause); } output.writeBoolean(false); output.writeUTF(exception.Message); output.writeInt((int)exception.severity); encodeStackTrace(output, exception); }
public override void EncodeTerm(long[] longs, DataOutput output, FieldInfo fi, BlockTermState state, bool absolute) { SepTermState state_ = (SepTermState)state; if (absolute) { lastSkipFP = 0; lastPayloadFP = 0; lastState = state_; } lastState.DocIndex.CopyFrom(state_.DocIndex, false); lastState.DocIndex.Write(output, absolute); if (indexOptions != IndexOptions.DOCS_ONLY) { lastState.FreqIndex.CopyFrom(state_.FreqIndex, false); lastState.FreqIndex.Write(output, absolute); if (indexOptions == IndexOptions.DOCS_AND_FREQS_AND_POSITIONS) { lastState.PosIndex.CopyFrom(state_.PosIndex, false); lastState.PosIndex.Write(output, absolute); if (storePayloads) { if (absolute) { output.WriteVInt64(state_.PayloadFP); } else { output.WriteVInt64(state_.PayloadFP - lastPayloadFP); } lastPayloadFP = state_.PayloadFP; } } } if (state_.SkipFP != -1) { if (absolute) { output.WriteVInt64(state_.SkipFP); } else { output.WriteVInt64(state_.SkipFP - lastSkipFP); } lastSkipFP = state_.SkipFP; } }
private void CreateReportViewer() { frmRpt = new frm_Report(); #region Подготовить данные для вывода в отчет // Исходные данные в отчет DataInput_HB _DataInput_HB = new DataInput_HB(HB); List<cReportList> RepListInputHB = new List<cReportList>(); foreach (HeatBalance.Class.Param par in _allParamsInput) { if (par.IsReport) { if (_DataInput_HB.GetType().GetProperty(par.PropertyName).GetValue(_DataInput_HB, null) != null) { double d = Math.Round(Convert.ToDouble( _DataInput_HB.GetType().GetProperty(par.PropertyName).GetValue( _DataInput_HB, null)), 3); RepListInputHB.Add(new HeatBalance.Class.cReportList(par.Description, d.ToString())); } } } frmRpt.cReportInputBindingSource.DataSource = RepListInputHB; // Результаты расчета в отчет DataOutput _dataOutput = new DataOutput(HB); List<cReportList> RepListOutput = new List<cReportList>(); foreach (HeatBalance.Class.Param par in _allParamsOutput) { if (par.IsReport) { double d = Math.Round(Convert.ToDouble( _dataOutput.GetType().GetProperty(par.PropertyName).GetValue(_dataOutput, null)), 3); RepListOutput.Add(new HeatBalance.Class.cReportList(par.Description, d.ToString())); } } #endregion #region Указать отчету источники данных frmRpt.cReportInputBindingSource.DataSource = RepListInputHB; frmRpt.cReportOutputBindingSource.DataSource = RepListOutput; #endregion #region Показать окно отчета на весь экран frmRpt.WindowState = FormWindowState.Maximized; frmRpt.ShowDialog(this); #endregion }
private static void WriteState( DataOutput output, CountMinSketchState state) { var hashes = state.Hashes; output.WriteInt(hashes.Depth); output.WriteInt(hashes.Width); var table = hashes.Table; output.WriteInt(table.Length); foreach (var row in table) { output.WriteInt(row.Length); foreach (var col in row) { output.WriteLong(col); } } var hash = hashes.Hash; output.WriteInt(hash.Length); foreach (var aHash in hash) { output.WriteLong(aHash); } output.WriteLong(hashes.Total); var topk = state.Topk; output.WriteBoolean(topk != null); if (topk != null) { output.WriteInt(topk.TopKMax); var topMap = topk.Topk; output.WriteInt(topMap.Count); foreach (var entry in topMap) { output.WriteLong(entry.Key); if (entry.Value is ByteBuffer byteBuffer) { output.WriteInt(1); WriteBytes(output, byteBuffer); } else { var q = (Deque<ByteBuffer>) entry.Value; output.WriteInt(q.Count); foreach (var buf in q) { WriteBytes(output, buf); } } } } }
public void ToData(DataOutput output) { output.WriteDouble(double_field); output.WriteFloat(float_field); output.WriteInt64(long_field); output.WriteInt32(int_field); output.WriteInt16(short_field); output.WriteUTF(string_field); int itemCount = string_vector.Count; output.WriteInt32(itemCount); for (int idx = 0; idx < itemCount; idx++) { string s = (string)string_vector[idx]; output.WriteUTF(s); } }
public override void writeTagContents(DataOutput dataoutput) { if (tagList.size() > 0) { tagType = ((NBTBase)tagList.get(0)).getType(); } else { tagType = 1; } dataoutput.writeByte(tagType); dataoutput.writeInt(tagList.size()); for (int i = 0; i < tagList.size(); i++) { ((NBTBase)tagList.get(i)).writeTagContents(dataoutput); } }
public override void WriteFinalOutput(object output, DataOutput @out) { if (!(output is IList)) { @out.WriteVInt32(1); outputs.Write((T)output, @out); } else { IList outputList = (IList)output; @out.WriteVInt32(outputList.Count); foreach (var eachOutput in outputList) { outputs.Write((T)eachOutput, @out); } } }
public override void Write(object output, DataOutput @out) { if (Debugging.AssertsEnabled) { Debugging.Assert(Valid(output, true)); } if (output is Int64 output2) { @out.WriteVInt64(output2 << 1); } else { TwoInt64s output3 = (TwoInt64s)output; @out.WriteVInt64((output3.First << 1) | 1); @out.WriteVInt64(output3.Second); } }
/// <summary> /// Serialize a /// <see cref="INodeSymlink"/> /// node /// </summary> /// <param name="node">The node to write</param> /// <param name="out"> /// The /// <see cref="System.IO.DataOutput"/> /// where the fields are written /// </param> /// <exception cref="System.IO.IOException"/> private static void WriteINodeSymlink(INodeSymlink node, DataOutput @out) { WriteLocalName(node, @out); @out.WriteLong(node.GetId()); @out.WriteShort(0); // replication @out.WriteLong(0); // modification time @out.WriteLong(0); // access time @out.WriteLong(0); // preferred block size @out.WriteInt(-2); // # of blocks Text.WriteString(@out, node.GetSymlinkString()); WritePermissionStatus(node, @out); }
public override void writeTagContents(DataOutput dataoutput) { if (tagList.size() > 0) { tagType = ((NBTBase) tagList.get(0)).getType(); } else { tagType = 1; } dataoutput.writeByte(tagType); dataoutput.writeInt(tagList.size()); for (int i = 0; i < tagList.size(); i++) { ((NBTBase) tagList.get(i)).writeTagContents(dataoutput); } }
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET: //ORIGINAL LINE: @Override public void writeFinalOutput(Object output, org.apache.lucene.store.DataOutput out) throws java.io.IOException public override void writeFinalOutput(object output, DataOutput @out) { if (!(output is IList)) { @out.writeVInt(1); outputs.write((T)output, @out); } else { IList <T> outputList = (IList <T>)output; @out.writeVInt(outputList.Count); foreach (T eachOutput in outputList) { outputs.write(eachOutput, @out); } } }
public void ToData(DataOutput output) { output.WriteInt32(m_id); output.WriteUTF(m_pkid); output.WriteObject(m_position1); output.WriteObject(m_position2); output.WriteDictionary((System.Collections.IDictionary)m_positions); output.WriteUTF(m_type); output.WriteUTF(m_status); output.WriteObject(m_names); output.WriteBytes(m_newVal); //output.WriteObject((IGFSerializable)(object)m_creationDate); // VJR: TODO //output.WriteObject(CacheableDate.Create(m_creationDate)); output.WriteDate(m_creationDate); output.WriteBytes(m_arrayNull); output.WriteBytes(m_arrayZeroSize); }
static void GetOrderInfoTest() { var @event = "getorderinfo"; Console.WriteLine($"{nameof(GetOrderInfoTest)} Start"); using (var ws = new WebSocket(URL)) { if (URL.StartsWith("wss", StringComparison.OrdinalIgnoreCase)) { ws.SslConfiguration.ServerCertificateValidationCallback = new RemoteCertificateValidationCallback(CheckValidationResult); } ws.OnMessage += (sender, e) => { var output = JsonConvert.DeserializeObject <DataOutput <dynamic> >(e.Data); if (output.Event == @event) { DataOutput <IList <GetOrderInfoOutput> > baseOutput = JsonConvert.DeserializeObject <DataOutput <IList <GetOrderInfoOutput> > >(e.Data); var parameters = baseOutput.Data == null ? string.Empty : JsonConvert.SerializeObject(baseOutput.Data); Console.WriteLine($"Parameters:{parameters} Result:{baseOutput.Result} Code:{baseOutput.ErrorCode} "); } if (output.Event == "login") { Console.WriteLine($"Result:{output.Result} Code:{output.ErrorCode}"); } }; GetOrderinfoEvent baseEvent = new GetOrderinfoEvent { Event = @event, Parameters = new Orderinfo { Symbol = "BTC/VHKD", Sign = Sign, ApiKey = ApiKey, OrderId = "EvIJUCwEp0CClKGlM8MRKg" } }; var data = JsonConvert.SerializeObject(baseEvent); ws.Connect(); Login(ws); Thread.Sleep(50); ws.Send(data); Console.ReadLine(); } Console.WriteLine($"{nameof(GetOrderInfoTest)} End"); }
public DataOutput CreateDataOutput(DataOutputViewModel viewModel) { if (viewModel == null) { throw new ArgumentNullException(nameof(viewModel)); } var output = new DataOutput { MimeType = viewModel.SelectedFormat.MimeType, Encoding = viewModel.SelectedFormat.SelectedEncoding, Schema = viewModel.SelectedFormat.SelectedSchema, Transmission = TransmissionMode.Value, Identifier = viewModel.Identifier }; return(output); }
private void WriteInternal( object[] @object, DataOutput output, byte[] unitKey, EventBeanCollatedWriter writer) { if (@object == null) { output.WriteInt(-1); return; } output.WriteInt(@object.Length); foreach (object i in @object) { _componentBinding.Write(i, output, unitKey, writer); } }
public override bool Store(DataOutput output) { UninterruptableMonitor.Enter(this); try { output.WriteVInt64(count); if (this.normalCompletion == null || normalCompletion.FST == null) { return(false); } normalCompletion.FST.Save(output); return(true); } finally { UninterruptableMonitor.Exit(this); } }
public override void Write(object output, DataOutput @out) { if (Debugging.AssertsEnabled) { Debugging.Assert(Valid(output, true)); } if (output is long?) { long?output2 = (long?)output; @out.WriteVInt64(output2.GetValueOrDefault() << 1); } else { TwoInt64s output3 = (TwoInt64s)output; @out.WriteVInt64((output3.First << 1) | 1); @out.WriteVInt64(output3.Second); } }
/// <summary>Save snapshots and snapshot quota for a snapshottable directory.</summary> /// <param name="current">The directory that the snapshots belongs to.</param> /// <param name="out"> /// The /// <see cref="System.IO.DataOutput"/> /// to write. /// </param> /// <exception cref="System.IO.IOException"/> public static void SaveSnapshots(INodeDirectory current, DataOutput @out) { DirectorySnapshottableFeature sf = current.GetDirectorySnapshottableFeature(); Preconditions.CheckArgument(sf != null); // list of snapshots in snapshotsByNames ReadOnlyList <Org.Apache.Hadoop.Hdfs.Server.Namenode.Snapshot.Snapshot> snapshots = sf.GetSnapshotList(); @out.WriteInt(snapshots.Size()); foreach (Org.Apache.Hadoop.Hdfs.Server.Namenode.Snapshot.Snapshot s in snapshots) { // write the snapshot id @out.WriteInt(s.GetId()); } // snapshot quota @out.WriteInt(sf.GetSnapshotQuota()); }
public void StringExcedesBufferCapacity() { DataOutput dataOutput = new DataOutput(); // Chcek that native buffer is unused and get initial capacity. Assert.AreEqual(0, dataOutput.BufferLength); int bufferSize = dataOutput.GetRemainingBufferLength(); // New string equal to buffer capacity. string s = "".PadRight(bufferSize, 'a'); dataOutput.WriteUTF(s); // Checks native buffer capacity, remaining length should be capacity since wrapper has not flushed to native yet. Assert.GreaterOrEqual(dataOutput.GetRemainingBufferLength(), bufferSize + 2, "Buffer should have been resized to account for string + 2 bytes of length"); // Forces native buffer to be updated and gets length of used buffers. Assert.AreEqual(bufferSize + 2, dataOutput.BufferLength, "Buffer length should be string plus 2 bytes for length."); }
/// <summary> /// NOTE: This was saveInts() in Lucene. /// </summary> private static void SaveInt32s(int[] values, int length, DataOutput @out) { if (Debugging.AssertsEnabled) { Debugging.Assert(length > 0); } if (length == 1) { @out.WriteVInt32(values[0]); } else { bool allEqual = true; for (int i = 1; i < length; ++i) { if (values[i] != values[0]) { allEqual = false; break; } } if (allEqual) { @out.WriteVInt32(0); @out.WriteVInt32(values[0]); } else { long max = 0; for (int i = 0; i < length; ++i) { max |= (uint)values[i]; } int bitsRequired = PackedInt32s.BitsRequired(max); @out.WriteVInt32(bitsRequired); PackedInt32s.Writer w = PackedInt32s.GetWriterNoHeader(@out, PackedInt32s.Format.PACKED, length, bitsRequired, 1); for (int i = 0; i < length; ++i) { w.Add(values[i]); } w.Finish(); } } }
public bool CompareTwoPositionObjects(TVal pos1, TVal pos2) { Position p1 = pos1 as Position; Position p2 = pos2 as Position; if (p1 == null || p2 == null) { Util.Log("The object(s) passed are not of Position type"); return(false); } DataOutput o1 = m_cache.CreateDataOutput(); DataOutput o2 = m_cache.CreateDataOutput(); p1.ToData(o1); p2.ToData(o2); var len1 = o1.BufferLength; var len2 = o2.BufferLength; if (len1 != len2) { return(false); } byte[] ptr1 = o1.GetBuffer(); byte[] ptr2 = o2.GetBuffer(); if (ptr1.Length != ptr2.Length) { return(false); } for (int i = ptr1.Length; i < ptr1.Length; i++) { if (ptr1[i] != ptr2[i]) { return(false); } } return(true); }
/// <exception cref="System.IO.IOException"/> public virtual void Write(DataOutput @out) { @out.WriteLong(totLength); @out.WriteInt(lengths.Length); foreach (long length in lengths) { @out.WriteLong(length); } @out.WriteInt(paths.Length); foreach (Path p in paths) { Text.WriteString(@out, p.ToString()); } @out.WriteInt(startoffset.Length); foreach (long length_1 in startoffset) { @out.WriteLong(length_1); } }
public static void WriteValue( object value, DataOutput output) { if (value == null) { output.WriteByte(NULL_TYPE); } else if (value is int intValue) { output.WriteByte(INT_TYPE); output.WriteInt(intValue); } else if (value is double doubleValue) { output.WriteByte(DOUBLE_TYPE); output.WriteDouble(doubleValue); } else if (value is string stringValue) { output.WriteByte(STRING_TYPE); output.WriteUTF(stringValue); } else if (value is bool boolValue) { output.WriteByte(BOOLEAN_TYPE); output.WriteBoolean(boolValue); } else if (value is IDictionary <string, object> dictionary) { output.WriteByte(OBJECT_TYPE); Write(dictionary, output); } else if (value is object[] objectArray) { output.WriteByte(ARRAY_TYPE); WriteArray(objectArray, output); } else { throw new IOException("Unrecognized json object type value of type " + value.GetType() + "'"); } }
public void CreateReportViewer() { frmRpt = new RepForm(); // Исходные данные в отчет только те, которые отметил пользователь (IsReport=true) DataInput _DataInput = new DataInput(c); List <cReportList> RepListInput = new List <cReportList>(); foreach (KonverSywul.Class.Param par in _allParamsInput) { if (par.IsReport) { if (_DataInput.GetType().GetProperty(par.PropertyName).GetValue(_DataInput, null) != null) { double d = Math.Round(Convert.ToDouble( _DataInput.GetType().GetProperty(par.PropertyName).GetValue( _DataInput, null)), 3); RepListInput.Add(new KonverSywul.Class.cReportList(par.Description, d.ToString())); } } } frmRpt.cReportInputBindingSource.DataSource = RepListInput; // Результаты расчета в отчет только те, которые отметил пользователь (IsReport=true) DataOutput _DataOutput = new DataOutput(c); List <cReportList> RepListOutput = new List <cReportList>(); foreach (KonverSywul.Class.Param par in _allParamsOutput) { if (par.IsReport) { double d = Math.Round(Convert.ToDouble( _DataOutput.GetType().GetProperty(par.PropertyName).GetValue(_DataOutput, null)), 3); RepListOutput.Add(new KonverSywul.Class.cReportList(par.Description, d.ToString())); } } // Указать отчету источники данных frmRpt.cReportInputBindingSource.DataSource = RepListInput; frmRpt.cParamOutputBindingSource.DataSource = RepListOutput; // Показать окно отчета на весь экран frmRpt.WindowState = FormWindowState.Maximized; frmRpt.ShowDialog(this); }
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET: //ORIGINAL LINE: private static void encodeStackTrace(DataOutput output, Throwable throwable) throws IOException private static void encodeStackTrace(DataOutput output, System.Exception throwable) { StackTraceElement[] trace = throwable.StackTrace; output.writeInt(trace.Length); foreach (StackTrace element in trace) { output.writeUTF(element.getClassName()); output.writeUTF(element.GetFrames().ToString()); string fileName = element.getFileName(); output.writeBoolean(!string.ReferenceEquals(fileName, null)); if (!string.ReferenceEquals(fileName, null)) { output.writeUTF(fileName); } output.writeInt(element.getLineNumber()); } }
/// <exception cref="System.IO.IOException"/> public virtual void WriteINodeReferenceWithCount(INodeReference.WithCount withCount , DataOutput @out, bool writeUnderConstruction) { INode referred = withCount.GetReferredINode(); long id = withCount.GetId(); bool firstReferred = !referenceMap.Contains(id); @out.WriteBoolean(firstReferred); if (firstReferred) { FSImageSerialization.SaveINode2Image(referred, @out, writeUnderConstruction, this ); referenceMap[id] = withCount; } else { @out.WriteLong(id); } }
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET: //ORIGINAL LINE: @Override public void write(Object _output, org.apache.lucene.store.DataOutput out) throws java.io.IOException public override void write(object _output, DataOutput @out) { Debug.Assert(valid(_output, true)); if (_output is long?) { //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final Long output = (Long) _output; long?output = (long?)_output; @out.writeVLong(output << 1); } else { //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final TwoLongs output = (TwoLongs) _output; TwoLongs output = (TwoLongs)_output; @out.writeVLong((output.first << 1) | 1); @out.writeVLong(output.second); } }
/// <summary> /// NOTE: Code-generation-invoked method, method name and parameter order matters /// </summary> /// <param name="output">output</param> /// <param name="unitKey">unit key</param> /// <param name="writer">writer</param> /// <param name="serdeNullable">binding</param> /// <param name="circularBuffer">buffer</param> /// <param name="numDataPoints">points</param> /// <param name="currentBufferElementPointer">pointer</param> /// <param name="sizeBuf">size</param> /// <throws>IOException io error</throws> public static void Write( DataOutput output, byte[] unitKey, EventBeanCollatedWriter writer, DataInputOutputSerdeWCollation<object> serdeNullable, object[] circularBuffer, long numDataPoints, int currentBufferElementPointer, int sizeBuf) { output.WriteBoolean(circularBuffer != null); if (circularBuffer != null) { output.WriteLong(numDataPoints); output.WriteInt(currentBufferElementPointer); for (var i = 0; i < sizeBuf; i++) { serdeNullable.Write(circularBuffer[i], output, unitKey, writer); } } }
public void ToData(DataOutput output) { output.WriteInt64(m_avg20DaysVol); output.WriteUTF(m_bondRating); output.WriteDouble(m_convRatio); output.WriteUTF(m_country); output.WriteDouble(m_delta); output.WriteInt64(m_industry); output.WriteInt64(m_issuer); output.WriteDouble(m_mktValue); output.WriteDouble(m_qty); output.WriteUTF(m_secId); output.WriteUTF(m_secLinks); output.WriteUTF(m_secType); output.WriteInt32(m_sharesOutstanding); output.WriteUTF(m_underlyer); output.WriteInt64(m_volatility); output.WriteInt32(m_pid); }
private void WriteInternal( object[] @object, DataOutput output) { if (@object == null) { output.WriteInt(-1); return; } output.WriteInt(@object.Length); foreach (var obj in @object) { byte[] data = DIOSerializableObjectSerde.ObjectToByteArr(obj); output.WriteInt(data.Length); output.Write(data); } }
static void SendOrderTest() { var @event = "sendorder"; Console.WriteLine($"{nameof(SendOrderTest)} Start"); using (var ws = new WebSocket(URL)) { if (URL.StartsWith("wss", StringComparison.OrdinalIgnoreCase)) { ws.SslConfiguration.ServerCertificateValidationCallback = new RemoteCertificateValidationCallback(CheckValidationResult); } ws.OnMessage += (sender, e) => { DataOutput <string> baseOutput = JsonConvert.DeserializeObject <DataOutput <string> >(e.Data); if (baseOutput.Event == @event) { var parameters = baseOutput.Data == null? "": JsonConvert.SerializeObject(baseOutput.Data); Console.WriteLine($"Parameters:{parameters} Result:{baseOutput.Result} Code:{baseOutput.ErrorCode} "); } }; SendOrderEvent baseEvent = new SendOrderEvent { Event = @event, Parameters = new OrderInfo { ApiKey = ApiKey, Sign = Sign, Symbol = "BTC/VHKD", Amount = 1, IsMarket = false, Price = (decimal)1, Type = "buy" } }; var data = JsonConvert.SerializeObject(baseEvent); ws.Connect(); Login(ws); Thread.Sleep(50); ws.Send(data); Console.ReadLine(); } Console.WriteLine($"{nameof(SendOrderTest)} End"); }
public override void Write(DataOutput indexOut, bool absolute) { Debug.Assert(_upto >= 0); if (absolute) { indexOut.WriteVInt(_upto); indexOut.WriteVLong(_fp); } else if (_fp == _lastFp) { // same block Debug.Assert(_upto >= _lastUpto); var uptoDelta = _upto - _lastUpto; indexOut.WriteVInt(uptoDelta << 1 | 1); } else { // new block indexOut.WriteVInt(_upto << 1); indexOut.WriteVLong(_fp - _lastFp); } _lastUpto = _upto; _lastFp = _fp; }
public override void writeTagContents(DataOutput dataoutput) { dataoutput.writeShort(shortValue); }
public override GetOutputResult GetOutput(DataOutput _Output) { var v = ((MainStationCodeBlock)DataInputs[0].Connected.Owner.Owner).GetOutput(DataInputs[0].Connected); var reg = MainStationCompiler.GetRegister(2); MemoryStream stream = new MemoryStream(); byte[] load = CodeInstructions.Load(reg.index, 0xffff); byte[] xor = CodeInstructions.Xor(v.Register.index, reg.index, reg.index); stream.Write(v.Code, 0, v.Code.Length); stream.Write(load, 0, load.Length); stream.Write(xor, 0, xor.Length); return new GetOutputResult(stream.ToArray(), reg); }
public override object HandleOutput(DataOutput _Output) { return !(bool)GetInput(DataInputs[0]); }
private static void EncodeLiterals(sbyte[] bytes, int token, int anchor, int literalLen, DataOutput @out) { @out.WriteByte((sbyte)token); // encode literal length if (literalLen >= 0x0F) { EncodeLen(literalLen - 0x0F, @out); } // encode literals @out.WriteBytes(bytes, anchor, literalLen); }
private static void EncodeLen(int l, DataOutput @out) { while (l >= 0xFF) { @out.WriteByte(unchecked((sbyte)0xFF)); l -= 0xFF; } @out.WriteByte((sbyte)l); }
public override void Compress(byte[] bytes, int off, int len, DataOutput output) { byte[] resultArray = null; using (MemoryStream compressionMemoryStream = new MemoryStream()) { using (DeflateStream deflateStream = new DeflateStream(compressionMemoryStream, compressionLevel)) { deflateStream.Write(bytes, off, len); } resultArray = compressionMemoryStream.ToArray(); } if (resultArray.Length == 0) { Debug.Assert(len == 0, len.ToString()); output.WriteVInt(0); return; } else { output.WriteVInt(resultArray.Length); output.WriteBytes(resultArray, resultArray.Length); } }
/// <summary> /// Compress <code>bytes[off:off+len]</code> into <code>out</code> using /// at most 16KB of memory. <code>ht</code> shouldn't be shared across threads /// but can safely be reused. /// </summary> public static void Compress(sbyte[] bytes, int off, int len, DataOutput @out, HashTable ht) { int @base = off; int end = off + len; int anchor = off++; if (len > LAST_LITERALS + MIN_MATCH) { int limit = end - LAST_LITERALS; int matchLimit = limit - MIN_MATCH; ht.Reset(len); int hashLog = ht.HashLog; PackedInts.Mutable hashTable = ht.hashTable; while (off <= limit) { // find a match int @ref; while (true) { if (off >= matchLimit) { goto mainBreak; } int v = ReadInt(bytes, off); int h = Hash(v, hashLog); @ref = @base + (int)hashTable.Get(h); Debug.Assert(PackedInts.BitsRequired(off - @base) <= hashTable.BitsPerValue); hashTable.Set(h, off - @base); if (off - @ref < MAX_DISTANCE && ReadInt(bytes, @ref) == v) { break; } ++off; } // compute match length int matchLen = MIN_MATCH + CommonBytes(bytes, @ref + MIN_MATCH, off + MIN_MATCH, limit); EncodeSequence(bytes, anchor, @ref, off, matchLen, @out); off += matchLen; anchor = off; mainContinue: ; } mainBreak: ; } // last literals int literalLen = end - anchor; Debug.Assert(literalLen >= LAST_LITERALS || literalLen == len); EncodeLastLiterals(bytes, anchor, end - anchor, @out); }
public virtual GetOutputResult GetOutput(DataOutput _Output) { throw new NotImplementedException(); }
public override object HandleOutput(DataOutput _Output) { float a = (float)GetInput(DataInputs[0]); float b = (float)GetInput(DataInputs[1]); return a - b; }
public override object HandleOutput(DataOutput _Output) { if (variables.ContainsKey(name)) return variables[name]; else return 0; }
public override object HandleOutput(DataOutput _Output) { throw new NotImplementedException(); }
public override object HandleOutput(DataOutput _Output) { return val; }
public override object HandleOutput(DataOutput _Output) { return Running; }
public override GetOutputResult GetOutput(DataOutput _Output) { var reg = MainStationCompiler.GetRegister(2); return new GetOutputResult(CodeInstructions.Load(reg.index, val), reg); }
/// <summary> /// Writes "location" of current output pointer of primary /// output to different output (out) /// </summary> public abstract void Write(DataOutput indexOut, bool absolute);
public override GetOutputResult GetOutput(DataOutput _Output) { var reg = MainStationCompiler.GetRegister(2); MemoryStream stream = new MemoryStream(); byte[] code; code = CodeInstructions.Load(reg.index, EventID); stream.Write(code, 0, code.Length); code = CodeInstructions.EPSend(DeviceID, (byte)(reg.size + 1)); stream.Write(code, 0, code.Length); code = CodeInstructions.Mov(0, reg.index, (byte)reg.size); stream.Write(code, 0, code.Length); return new GetOutputResult(stream.ToArray(), reg); }
private void SaveAppropriatelySizedBloomFilter(DataOutput bloomOutput, FuzzySet bloomFilter, FieldInfo fieldInfo) { var rightSizedSet = _bfpf._bloomFilterFactory.Downsize(fieldInfo, bloomFilter) ?? bloomFilter; rightSizedSet.Serialize(bloomOutput); }
public override void Compress(sbyte[] bytes, int off, int len, DataOutput @out) { @out.WriteBytes(bytes, off, len); }
private static void EncodeSequence(sbyte[] bytes, int anchor, int matchRef, int matchOff, int matchLen, DataOutput @out) { int literalLen = matchOff - anchor; Debug.Assert(matchLen >= 4); // encode token int token = (Math.Min(literalLen, 0x0F) << 4) | Math.Min(matchLen - 4, 0x0F); EncodeLiterals(bytes, token, anchor, literalLen, @out); // encode match dec int matchDec = matchOff - matchRef; Debug.Assert(matchDec > 0 && matchDec < 1 << 16); @out.WriteByte((sbyte)matchDec); @out.WriteByte((sbyte)((int)((uint)matchDec >> 8))); // encode match len if (matchLen >= MIN_MATCH + 0x0F) { EncodeLen(matchLen - 0x0F - MIN_MATCH, @out); } }
public override void Compress(byte[] bytes, int off, int len, DataOutput @out) { LZ4.CompressHC(bytes, off, len, @out, Ht); }
public override void EncodeTerm(long[] longs, DataOutput @out, FieldInfo fieldInfo, BlockTermState _state, bool absolute) { IntBlockTermState state = (IntBlockTermState)_state; if (absolute) { LastState = EmptyState; } longs[0] = state.DocStartFP - LastState.DocStartFP; if (FieldHasPositions) { longs[1] = state.PosStartFP - LastState.PosStartFP; if (FieldHasPayloads || FieldHasOffsets) { longs[2] = state.PayStartFP - LastState.PayStartFP; } } if (state.SingletonDocID != -1) { @out.WriteVInt(state.SingletonDocID); } if (FieldHasPositions) { if (state.LastPosBlockOffset != -1) { @out.WriteVLong(state.LastPosBlockOffset); } } if (state.SkipOffset != -1) { @out.WriteVLong(state.SkipOffset); } LastState = state; }
/// <summary> /// Writes all of our bytes to the target <seealso cref="DataOutput"/>. </summary> public virtual void WriteTo(DataOutput @out) { foreach (byte[] block in Blocks) { @out.WriteBytes(block, 0, block.Length); } }
/// <summary> /// Compress <code>bytes[off:off+len]</code> into <code>out</code>. Compared to /// <seealso cref="LZ4#compress(byte[], int, int, DataOutput, HashTable)"/>, this method /// is slower and uses more memory (~ 256KB per thread) but should provide /// better compression ratios (especially on large inputs) because it chooses /// the best match among up to 256 candidates and then performs trade-offs to /// fix overlapping matches. <code>ht</code> shouldn't be shared across threads /// but can safely be reused. /// </summary> public static void CompressHC(sbyte[] src, int srcOff, int srcLen, DataOutput @out, HCHashTable ht) { int srcEnd = srcOff + srcLen; int matchLimit = srcEnd - LAST_LITERALS; int mfLimit = matchLimit - MIN_MATCH; int sOff = srcOff; int anchor = sOff++; ht.Reset(srcOff); Match match0 = new Match(); Match match1 = new Match(); Match match2 = new Match(); Match match3 = new Match(); while (sOff <= mfLimit) { if (!ht.InsertAndFindBestMatch(src, sOff, matchLimit, match1)) { ++sOff; continue; } // saved, in case we would skip too much CopyTo(match1, match0); while (true) { Debug.Assert(match1.Start >= anchor); if (match1.End() >= mfLimit || !ht.InsertAndFindWiderMatch(src, match1.End() - 2, match1.Start + 1, matchLimit, match1.Len, match2)) { // no better match EncodeSequence(src, anchor, match1.@ref, match1.Start, match1.Len, @out); anchor = sOff = match1.End(); goto mainContinue; } if (match0.Start < match1.Start) { if (match2.Start < match1.Start + match0.Len) // empirical { CopyTo(match0, match1); } } Debug.Assert(match2.Start > match1.Start); if (match2.Start - match1.Start < 3) // First Match too small : removed { CopyTo(match2, match1); goto search2Continue; } while (true) { if (match2.Start - match1.Start < OPTIMAL_ML) { int newMatchLen = match1.Len; if (newMatchLen > OPTIMAL_ML) { newMatchLen = OPTIMAL_ML; } if (match1.Start + newMatchLen > match2.End() - MIN_MATCH) { newMatchLen = match2.Start - match1.Start + match2.Len - MIN_MATCH; } int correction = newMatchLen - (match2.Start - match1.Start); if (correction > 0) { match2.Fix(correction); } } if (match2.Start + match2.Len >= mfLimit || !ht.InsertAndFindWiderMatch(src, match2.End() - 3, match2.Start, matchLimit, match2.Len, match3)) { // no better match -> 2 sequences to encode if (match2.Start < match1.End()) { match1.Len = match2.Start - match1.Start; } // encode seq 1 EncodeSequence(src, anchor, match1.@ref, match1.Start, match1.Len, @out); anchor = sOff = match1.End(); // encode seq 2 EncodeSequence(src, anchor, match2.@ref, match2.Start, match2.Len, @out); anchor = sOff = match2.End(); goto mainContinue; } if (match3.Start < match1.End() + 3) // Not enough space for match 2 : remove it { if (match3.Start >= match1.End()) // // can write Seq1 immediately ==> Seq2 is removed, so Seq3 becomes Seq1 { if (match2.Start < match1.End()) { int correction = match1.End() - match2.Start; match2.Fix(correction); if (match2.Len < MIN_MATCH) { CopyTo(match3, match2); } } EncodeSequence(src, anchor, match1.@ref, match1.Start, match1.Len, @out); anchor = sOff = match1.End(); CopyTo(match3, match1); CopyTo(match2, match0); goto search2Continue; } CopyTo(match3, match2); goto search3Continue; } // OK, now we have 3 ascending matches; let's write at least the first one if (match2.Start < match1.End()) { if (match2.Start - match1.Start < 0x0F) { if (match1.Len > OPTIMAL_ML) { match1.Len = OPTIMAL_ML; } if (match1.End() > match2.End() - MIN_MATCH) { match1.Len = match2.End() - match1.Start - MIN_MATCH; } int correction = match1.End() - match2.Start; match2.Fix(correction); } else { match1.Len = match2.Start - match1.Start; } } EncodeSequence(src, anchor, match1.@ref, match1.Start, match1.Len, @out); anchor = sOff = match1.End(); CopyTo(match2, match1); CopyTo(match3, match2); goto search3Continue; search3Continue: ; } search3Break: ; search2Continue: ; } search2Break: ; mainContinue: ; } mainBreak: EncodeLastLiterals(src, anchor, srcEnd - anchor, @out); }
public override void writeTagContents(DataOutput dataoutput) { dataoutput.writeDouble(doubleValue); }
public void write(DataOutput @out) { //serialize path, offset, length using FileSplit base.write(@out); int flags = (_hasBase ? OrcSplit.BASE_FLAG : 0) | (_isOriginal ? OrcSplit.ORIGINAL_FLAG : 0) | (_hasFooter ? OrcSplit.FOOTER_FLAG : 0); @out.writeByte(flags); @out.writeInt(deltas.Count); foreach (AcidInputFormat.DeltaMetaData delta in deltas) { delta.write(@out); } if (_hasFooter) { // serialize FileMetaInfo fields Text.writeString(@out, fileMetaInfo.compressionType); WritableUtils.writeVInt(@out, fileMetaInfo.bufferSize); WritableUtils.writeVInt(@out, fileMetaInfo.metadataSize); // serialize FileMetaInfo field footer ByteBuffer footerBuff = fileMetaInfo.footerBuffer; footerBuff.reset(); // write length of buffer WritableUtils.writeVInt(@out, footerBuff.limit() - footerBuff.position()); @out.write(footerBuff.array(), footerBuff.position(), footerBuff.limit() - footerBuff.position()); WritableUtils.writeVInt(@out, fileMetaInfo.writerVersion.getId()); } }
private static void EncodeLastLiterals(sbyte[] bytes, int anchor, int literalLen, DataOutput @out) { int token = Math.Min(literalLen, 0x0F) << 4; EncodeLiterals(bytes, token, anchor, literalLen, @out); }
public override void writeTagContents(DataOutput dataoutput) { }