private static void WriteJavaMethod(this DataOutputStream stream, MetadataJavaMethod method) { stream.WriteUTF(method.Name); stream.WriteUTF(method.ReturnType); stream.WriteAccessFlagsParameter(method.AccessFlags); stream.WriteArray(method.Parameters, stream.WriteJavaParameter); }
private static void WriteJavaField(this DataOutputStream stream, MetadataJavaField field) { stream.WriteUTF(field.Name); stream.WriteUTF(field.Type); stream.WriteAccessFlagsParameter(field.AccessFlags); stream.WriteBoolean(field.ConstantValue != null); if (field.ConstantValue != null) { stream.WriteArray(field.ConstantValue, b => stream.WriteByte(b)); } }
public virtual void Save(DataOutputStream @out) { try { @out.WriteUTF(word); @out.WriteUTF(tag); } catch (Exception e) { Sharpen.Runtime.PrintStackTrace(e); } }
/// <summary>Write a string representation of a Pair to a DataStream.</summary> /// <remarks> /// Write a string representation of a Pair to a DataStream. /// The <code>toString()</code> method is called on each of the pair /// of objects and a <code>String</code> representation is written. /// This might not allow one to recover the pair of objects unless they /// are of type <code>String</code>. /// </remarks> public virtual void Save(DataOutputStream @out) { try { @out.WriteUTF(first.ToString()); @out.WriteUTF(second.ToString()); } catch (Exception e) { Sharpen.Runtime.PrintStackTrace(e); } }
/// <exception cref="System.IO.IOException"/> public virtual void WriteApplicationACLs(IDictionary <ApplicationAccessType, string > appAcls) { DataOutputStream @out = this.writer.PrepareAppendKey(-1); ApplicationAclKey.Write(@out); @out.Close(); @out = this.writer.PrepareAppendValue(-1); foreach (KeyValuePair <ApplicationAccessType, string> entry in appAcls) { @out.WriteUTF(entry.Key.ToString()); @out.WriteUTF(entry.Value); } @out.Close(); }
private void WriteToDisk(System.IO.IsolatedStorage.IsolatedStorageFile iso, string storeFile) { DataOutputStream dos = FileUtils.WriteIsolatedStorageFileToDataInput(iso, storeFile); try { dos.WriteUTF(HEADER); dos.WriteInt(nextRecordId); dos.WriteInt(records.Count); for (int i = 0; i < records.Count; i++) { RecordItem ri = records[i]; long pSize = ri.data.Length; int pId = ri.id; dos.WriteLong(pSize); dos.WriteInt(pId); dos.Write(ri.data); } } catch (Exception e) { throw new RecordStoreException("Error writing store to disk: " + e.StackTrace); } finally { if (dos != null) { dos.Close(); } dos = null; } }
/* * public void save(String filename) { * try { * DataOutputStream rf = IOUtils.getDataOutputStream(filename); * save(rf); * rf.close(); * } catch (Exception e) { * e.printStackTrace(); * } * } */ internal virtual void Save(DataOutputStream file) { string[] arr = Sharpen.Collections.ToArray(dict.Keys, new string[dict.Keys.Count]); try { file.WriteInt(arr.Length); log.Info("Saving dictionary of " + arr.Length + " words ..."); foreach (string word in arr) { TagCount count = Get(word); file.WriteUTF(word); count.Save(file); } int[] arrverbs = Sharpen.Collections.ToArray(this.partTakingVerbs.Keys, new int[partTakingVerbs.Keys.Count]); file.WriteInt(arrverbs.Length); foreach (int iO in arrverbs) { CountWrapper tC = this.partTakingVerbs[iO]; file.WriteInt(iO); tC.Save(file); } } catch (Exception e) { Sharpen.Runtime.PrintStackTrace(e); } }
public override void ToOutputStream(DataOutputStream writer) { //Server to Client writer.WriteBoolean(DeckImage != null); if (DeckImage != null) { writer.WriteInt(ImageSlot); //Byte array lenght writer.WriteInt(DeckImage.InternalBitmap.Length); writer.Write(DeckImage.InternalBitmap); Json headerContent = new Json(); headerContent.Font = " "; headerContent.Size = CurrentItem.Decksize; headerContent.Position = CurrentItem.Deckposition; headerContent.Text = CurrentItem.Deckname; headerContent.Color = CurrentItem.Deckcolor; headerContent.Stroke_color = CurrentItem.Stroke_color; headerContent.Stroke_dx = CurrentItem.Stroke_dxtext; headerContent.Stroke_radius = CurrentItem.Stroke_radius; headerContent.Stroke_dy = CurrentItem.Stroke_Dy; headerContent.IsStroke = CurrentItem.IsStroke; headerContent.Isboldtext = CurrentItem.Isboldtext; headerContent.Isnormaltext = CurrentItem.Isnormaltext; headerContent.Isitalictext = CurrentItem.Isitalictext; headerContent.Ishinttext = CurrentItem.Ishinttext; string jsonString = JsonConvert.SerializeObject(headerContent, Formatting.None); writer.WriteUTF(jsonString); } }
/// <summary> /// <see cref="AsyncTask.DoInBackground(Java.Lang.Object[])"/> /// </summary> override protected Java.Lang.Object DoInBackground(params Java.Lang.Object[] @params) { ServerSocket serverSocket = new ServerSocket(m_Port); Socket clientSocket = serverSocket.Accept(); int res; List <byte> buffer = new List <byte>(); while ((res = clientSocket.InputStream.ReadByte()) != -1) { buffer.Add((byte)res); } m_Activity.RunOnUiThread(() => { Toast.MakeText(m_Activity, $"Message received : {System.Text.Encoding.UTF8.GetString(buffer.ToArray())}", ToastLength.Short).Show(); }); DataOutputStream outputStream = new DataOutputStream(clientSocket.OutputStream); outputStream.WriteUTF("Merci !"); outputStream.Close(); m_Activity.RunOnUiThread(() => { Toast.MakeText(m_Activity, $"Message sent : Merci !", ToastLength.Short).Show(); }); serverSocket.Close(); return(null); }
public static MetadataJavaField ToMetadata(this JavaField field) { var javaField = new MetadataJavaField { Name = field.Name, Type = field.Type.GetSignature() }; if (field.ConstantValue != null) { using var stream = new MemoryStream(); using var ms = new MemoryOutputStream(stream); using var dos = new DataOutputStream(ms); field.ConstantValue.Dump(dos); //Write the original string there to be able to create a new constantpool from metadata if (field.ConstantValue is ConstantString constantString) { dos.WriteUTF(constantString.GetBytes(field.ConstantPool)); } javaField.ConstantValue = stream.ToArray(); } return(javaField); }
public int write(DataOutputStream dos) { int size = 5; dos.WriteUTF(Streamable.MESSAGE_IONO); // 5 dos.WriteInt(STREAM_V); size += 4; dos.WriteLong(health); size += 8; dos.WriteDouble(utcA1); size += 8; dos.WriteDouble(utcA0); size += 8; dos.WriteLong(utcTOW); size += 8; dos.WriteInt(utcWNT); size += 4; dos.WriteInt(utcLS); size += 4; dos.WriteInt(utcWNF); size += 4; dos.WriteInt(utcDN); size += 4; dos.WriteInt(utcLSF); size += 4; for (int i = 0; i < alpha.Count(); i++) { dos.WriteFloat(alpha[i]); size += 4; } for (int i = 0; i < beta.Count(); i++) { dos.WriteFloat(beta[i]); size += 4; } dos.WriteBoolean(validHealth); size += 1; dos.WriteBoolean(validUTC); size += 1; dos.WriteBoolean(validKlobuchar); size += 1; dos.WriteLong(refTime == null ? -1 : refTime.getMsec()); size += 8; return(size); }
/// <summary> /// Serialize the token data for communication between server and client. /// </summary> /// <exception cref="IOException"></exception> public void Serialize(DataOutputStream writer) { writer.WriteUTF(Id); writer.WriteUTF(Version); writer.WriteInt32(SourceFiles.Count); foreach (KeyValuePair <string, IList <RevisionFile> > pair in SourceFiles) { writer.WriteUTF(pair.Key); writer.WriteInt32(pair.Value.Count); foreach (RevisionFile file in pair.Value) { writer.WriteUTF(file.FileName); writer.WriteInt64(file.Length); } } }
public void Run() { Socket socket = new Socket("10.0.0.25", 1800); DataOutputStream outputStream = new DataOutputStream(socket.OutputStream); outputStream.WriteUTF("Hello World! Java..."); socket.Close(); }
/// <exception cref="System.IO.IOException"/> public virtual void WriteApplicationOwner(string user) { DataOutputStream @out = this.writer.PrepareAppendKey(-1); ApplicationOwnerKey.Write(@out); @out.Close(); @out = this.writer.PrepareAppendValue(-1); @out.WriteUTF(user); @out.Close(); }
public override void ToOutputStream(DataOutputStream writer) { //From server to client //Tell the client if they are going to receive a device Guid writer.WriteBoolean(!hasDeviceGuid); if (!hasDeviceGuid) { DeviceGuid = Guid.NewGuid(); writer.WriteUTF(DeviceGuid.ToString()); } }
private static void WriteJarClass(this DataOutputStream stream, MetadataJavaClass @class) { stream.WriteUTF(@class.ClassName); stream.WriteAccessFlagsParameter(@class.AccessFlags); stream.WriteArray(@class.Interfaces, stream.WriteUTF); stream.WriteArray(@class.AllInterfaces, stream.WriteUTF); stream.WriteArray(@class.Interfaces, stream.WriteUTF); stream.WriteArray(@class.AllSuperClasses, stream.WriteUTF); stream.WriteArray(@class.Methods, stream.WriteJavaMethod); stream.WriteArray(@class.Fields, stream.WriteJavaField); }
/// <summary> /// <see cref="AsyncTask.DoInBackground(Java.Lang.Object[])"/> /// </summary> protected override Java.Lang.Object DoInBackground(params Java.Lang.Object[] @params) { ServerSocket serverSocket = new ServerSocket(m_Port); Socket clientSocket = serverSocket.Accept(); DataOutputStream outputStream = new DataOutputStream(clientSocket.OutputStream); outputStream.WriteUTF("Coucou"); outputStream.Flush(); return(null); }
public override void ToOutputStream(DataOutputStream writer) { //Server to Client if (String.IsNullOrEmpty(Text) == false) { writer.WriteInt(Id); //font writer.WriteUTF(Font); //text writer.WriteUTF(Text); //size writer.WriteInt(Size); //position writer.WriteInt(Position); //color writer.WriteUTF(Color); } }
/// <summary>Saves the object to the file.</summary> /// <param name="rf"> /// is a file handle /// Supposedly other objects will be written after this one in the file. The method does not close the file. The TagCount is saved at the current position. /// </param> protected internal virtual void Save(DataOutputStream rf) { try { rf.WriteInt(map.Count); foreach (string tag in map.Keys) { if (tag == null) { rf.WriteUTF(NullSymbol); } else { rf.WriteUTF(tag); } rf.WriteInt(map[tag]); } } catch (Exception e) { Sharpen.Runtime.PrintStackTrace(e); } }
/* (non-Javadoc) * @see org.gogpsproject.Streamable#write(java.io.DataOutputStream) */ public int write(DataOutputStream dos) { int size = 5; dos.WriteUTF(Streamable.MESSAGE_EPHEMERIS); // 5 dos.WriteInt(STREAM_V); size += 4; // 4 dos.WriteLong(refTime == null?-1:refTime.getMsec()); size += 8; dos.Write(satID); size += 1; dos.WriteInt(week); size += 4; dos.WriteInt(L2Code); size += 4; dos.WriteInt(L2Flag); size += 4; dos.WriteInt(svAccur); size += 4; dos.WriteInt(svHealth); size += 4; dos.WriteInt(iode); size += 4; dos.WriteInt(iodc); size += 4; dos.WriteDouble(toc); size += 8; dos.WriteDouble(toe); size += 8; dos.WriteDouble(af0); size += 8; dos.WriteDouble(af1); size += 8; dos.WriteDouble(af2); size += 8; dos.WriteDouble(tgd); size += 8; dos.WriteDouble(rootA); size += 8; dos.WriteDouble(e); size += 8; dos.WriteDouble(i0); size += 8; dos.WriteDouble(iDot); size += 8; dos.WriteDouble(omega); size += 8; dos.WriteDouble(omega0); size += 8; dos.WriteDouble(omegaDot); size += 8; dos.WriteDouble(M0); size += 8; dos.WriteDouble(deltaN); size += 8; dos.WriteDouble(crc); size += 8; dos.WriteDouble(crs); size += 8; dos.WriteDouble(cuc); size += 8; dos.WriteDouble(cus); size += 8; dos.WriteDouble(cic); size += 8; dos.WriteDouble(cis); size += 8; dos.WriteDouble(fitInt); size += 8; return(size); }
private void SendDeckLabel(DataOutputStream writer, int slot, DeckItemMisc item) { //Write the slot if (item.GetItemImage() != null) { Json headerContent = new Json(); writer.WriteInt(slot); //Byte array lenght writer.WriteInt(item.GetItemImage().InternalBitmap.Length); writer.Write(item.GetItemImage().InternalBitmap); headerContent.Font = " "; headerContent.Size = item.Decksize; headerContent.Position = item.Deckposition; headerContent.Text = item.Deckname; headerContent.Color = item.Deckcolor; headerContent.Stroke_color = item.Stroke_color; headerContent.Stroke_dx = item.Stroke_dxtext; headerContent.Stroke_radius = item.Stroke_radius; headerContent.Stroke_dy = item.Stroke_Dy; headerContent.IsStroke = item.IsStroke; headerContent.Isboldtext = item.Isboldtext; headerContent.Isnormaltext = item.Isnormaltext; headerContent.Isitalictext = item.Isitalictext; headerContent.Ishinttext = item.Ishinttext; string jsonString = JsonConvert.SerializeObject(headerContent, Formatting.None); writer.WriteUTF(jsonString); ////text //writer.WriteUTF(text); ////size //writer.WriteInt(size); ////position //writer.WriteInt(pos); ////color //writer.WriteUTF(color); } }
protected internal virtual void Save(DataOutputStream file, IDictionary <string, ICollection <string> > tagTokens) { try { file.WriteInt(index.Size()); foreach (string item in index) { file.WriteUTF(item); if (learnClosedTags) { if (tagTokens[item].Count < closedTagThreshold) { MarkClosed(item); } } file.WriteBoolean(IsClosed(item)); } } catch (IOException e) { throw new RuntimeIOException(e); } }
/** * Entry point to the Compile application. * <p> * This program takes any number of arguments: the first is the name of the * desired stemming algorithm to use (a list is available in the package * description) , all of the rest should be the path or paths to a file or * files containing a stemmer table to compile. * * @param args the command line arguments */ public static void Main(string[] args) { if (args.Length < 1) { return; } args[0].ToUpperInvariant(); backward = args[0][0] == '-'; int qq = (backward) ? 1 : 0; bool storeorig = false; if (args[0][qq] == '0') { storeorig = true; qq++; } multi = args[0][qq] == 'M'; if (multi) { qq++; } // LUCENENET TODO: Is this any different than Encoding.UTF8? //String charset = System.getProperty("egothor.stemmer.charset", "UTF-8"); char[] optimizer = new char[args[0].Length - qq]; for (int i = 0; i < optimizer.Length; i++) { optimizer[i] = args[0][qq + i]; } for (int i = 1; i < args.Length; i++) { TextReader @in; // System.out.println("[" + args[i] + "]"); Diff diff = new Diff(); //int stems = 0; // not used int words = 0; AllocTrie(); Console.WriteLine(args[i]); using (@in = new StreamReader( new FileStream(args[i], FileMode.Open, FileAccess.Read), Encoding.UTF8)) { for (string line = @in.ReadLine(); line != null; line = @in.ReadLine()) { try { line = line.ToLowerInvariant(); StringTokenizer st = new StringTokenizer(line); string stem = st.NextToken(); if (storeorig) { trie.Add(stem, "-a"); words++; } while (st.HasMoreTokens()) { string token = st.NextToken(); if (token.Equals(stem) == false) { trie.Add(token, diff.Exec(token, stem)); words++; } } } catch (InvalidOperationException /*x*/) { // no base token (stem) on a line } } } Optimizer o = new Optimizer(); Optimizer2 o2 = new Optimizer2(); Lift l = new Lift(true); Lift e = new Lift(false); Gener g = new Gener(); for (int j = 0; j < optimizer.Length; j++) { string prefix; switch (optimizer[j]) { case 'G': trie = trie.Reduce(g); prefix = "G: "; break; case 'L': trie = trie.Reduce(l); prefix = "L: "; break; case 'E': trie = trie.Reduce(e); prefix = "E: "; break; case '2': trie = trie.Reduce(o2); prefix = "2: "; break; case '1': trie = trie.Reduce(o); prefix = "1: "; break; default: continue; } trie.PrintInfo(System.Console.Out, prefix + " "); } using (DataOutputStream os = new DataOutputStream( new FileStream(args[i] + ".out", FileMode.OpenOrCreate, FileAccess.Write))) { os.WriteUTF(args[0]); trie.Store(os); } } }
/// <summary> /// Entry point to the Compile application. /// <para/> /// This program takes any number of arguments: the first is the name of the /// desired stemming algorithm to use (a list is available in the package /// description) , all of the rest should be the path or paths to a file or /// files containing a stemmer table to compile. /// </summary> /// <param name="args">the command line arguments</param> public static void Main(string[] args) { if (args.Length < 1) { return; } // LUCENENET NOTE: This line does nothing in .NET // and also does nothing in Java...what? //args[0].ToUpperInvariant(); // Reads the first char of the first arg backward = args[0][0] == '-'; int qq = (backward) ? 1 : 0; bool storeorig = false; if (args[0][qq] == '0') { storeorig = true; qq++; } multi = args[0][qq] == 'M'; if (multi) { qq++; } // LUCENENET specific - reformatted with : string charset = SystemProperties.GetProperty("egothor:stemmer:charset", "UTF-8"); var stemmerTables = new List <string>(); // LUCENENET specific // command line argument overrides environment variable or default, if supplied for (int i = 1; i < args.Length; i++) { if ("-e".Equals(args[i], StringComparison.Ordinal) || "--encoding".Equals(args[i], StringComparison.Ordinal)) { charset = args[i]; } else { stemmerTables.Add(args[i]); } } char[] optimizer = new char[args[0].Length - qq]; for (int i = 0; i < optimizer.Length; i++) { optimizer[i] = args[0][qq + i]; } foreach (var stemmerTable in stemmerTables) { // System.out.println("[" + args[i] + "]"); Diff diff = new Diff(); //int stems = 0; // not used int words = 0; AllocTrie(); Console.WriteLine(stemmerTable); using (TextReader input = new StreamReader( new FileStream(stemmerTable, FileMode.Open, FileAccess.Read), Encoding.GetEncoding(charset))) { string line; while ((line = input.ReadLine()) != null) { try { line = line.ToLowerInvariant(); StringTokenizer st = new StringTokenizer(line); st.MoveNext(); string stem = st.Current; if (storeorig) { trie.Add(stem, "-a"); words++; } while (st.MoveNext()) { string token = st.Current; if (token.Equals(stem, StringComparison.Ordinal) == false) { trie.Add(token, diff.Exec(token, stem)); words++; } } } catch (InvalidOperationException /*x*/) { // no base token (stem) on a line } } } Optimizer o = new Optimizer(); Optimizer2 o2 = new Optimizer2(); Lift l = new Lift(true); Lift e = new Lift(false); Gener g = new Gener(); for (int j = 0; j < optimizer.Length; j++) { string prefix; switch (optimizer[j]) { case 'G': trie = trie.Reduce(g); prefix = "G: "; break; case 'L': trie = trie.Reduce(l); prefix = "L: "; break; case 'E': trie = trie.Reduce(e); prefix = "E: "; break; case '2': trie = trie.Reduce(o2); prefix = "2: "; break; case '1': trie = trie.Reduce(o); prefix = "1: "; break; default: continue; } trie.PrintInfo(Console.Out, prefix + " "); } using (DataOutputStream os = new DataOutputStream( new FileStream(stemmerTable + ".out", FileMode.OpenOrCreate, FileAccess.Write))) { os.WriteUTF(args[0]); trie.Store(os); } } }
public override void ToOutputStream(DataOutputStream writer) { //To client writer.WriteUTF(ApplicationSettingsManager.Settings.DeviceName); }
/// <summary>Computes and returns the value of SVUID.</summary> /// <returns>the serial version UID.</returns> /// <exception cref="IOException">if an I/O error occurs.</exception> protected internal virtual long ComputeSVUID() { // DontCheck(AbbreviationAsWordInName): can't be renamed (for backward binary compatibility). long svuid = 0; using (var byteArrayOutputStream = new MemoryStream()) { using (var dataOutputStream = new DataOutputStream(byteArrayOutputStream.ToOutputStream() )) { // 1. The class name written using UTF encoding. dataOutputStream.WriteUTF(name.Replace('/', '.')); // 2. The class modifiers written as a 32-bit integer. var mods = access; if (mods.HasFlagFast(AccessFlags.Interface)) { mods = svuidMethods.Count == 0 ? mods & ~AccessFlags.Abstract : mods | AccessFlags.Abstract; } dataOutputStream.WriteInt((int)(mods & (AccessFlags.Public | AccessFlags.Final | AccessFlags.Interface | AccessFlags.Abstract))); // 3. The name of each interface sorted by name written using UTF encoding. Array.Sort(interfaces); foreach (var interfaceName in interfaces) { dataOutputStream.WriteUTF(interfaceName.Replace('/', '.')); } // 4. For each field of the class sorted by field name (except private static and private // transient fields): // 1. The name of the field in UTF encoding. // 2. The modifiers of the field written as a 32-bit integer. // 3. The descriptor of the field in UTF encoding. // Note that field signatures are not dot separated. Method and constructor signatures are dot // separated. Go figure... WriteItems(svuidFields, dataOutputStream, false); // 5. If a class initializer exists, write out the following: // 1. The name of the method, <clinit>, in UTF encoding. // 2. The modifier of the method, ACC_STATIC, written as a 32-bit integer. // 3. The descriptor of the method, ()V, in UTF encoding. if (hasStaticInitializer) { dataOutputStream.WriteUTF(Clinit); dataOutputStream.WriteInt((int)AccessFlags.Static); dataOutputStream.WriteUTF("()V"); } // 6. For each non-private constructor sorted by method name and signature: // 1. The name of the method, <init>, in UTF encoding. // 2. The modifiers of the method written as a 32-bit integer. // 3. The descriptor of the method in UTF encoding. WriteItems(svuidConstructors, dataOutputStream, true); // 7. For each non-private method sorted by method name and signature: // 1. The name of the method in UTF encoding. // 2. The modifiers of the method written as a 32-bit integer. // 3. The descriptor of the method in UTF encoding. WriteItems(svuidMethods, dataOutputStream, true); dataOutputStream.Flush(); // 8. The SHA-1 algorithm is executed on the stream of bytes produced by DataOutputStream and // produces five 32-bit values sha[0..4]. var hashBytes = ComputeSHAdigest(byteArrayOutputStream.ToArray()); // 9. The hash value is assembled from the first and second 32-bit values of the SHA-1 message // digest. If the result of the message digest, the five 32-bit words H0 H1 H2 H3 H4, is in an // array of five int values named sha, the hash value would be computed as follows: for (var i = Math.Min(hashBytes.Length, 8) - 1; i >= 0; i--) { svuid = (svuid << 8) | (hashBytes[i] & 0xFF); } } } return(svuid); }
public void FileWriteString(string val) { OutputStream.WriteUTF(val); }
private static void WriteJavaParameter(this DataOutputStream stream, MetadataJavaMethodParameter parameter) { stream.WriteUTF(parameter.Name); stream.WriteUTF(parameter.Type); }
private static void WriteJarArchiveClass(this DataOutputStream stream, string name, MetadataJavaClass @class) { stream.WriteUTF(name); stream.WriteJarClass(@class); }
/// <exception cref="System.IO.IOException"/> protected internal virtual void Save(DataOutputStream f) { f.WriteInt(num); f.WriteUTF(val); f.WriteUTF(tag); }