private static void GetEncodings(IntPtr info) { NSJSFunctionCallbackInfo arguments = NSJSFunctionCallbackInfo.From(info); var encodings = ENCODING.GetEncodings(); arguments.SetReturnValue(ArrayAuxiliary.ToArray(arguments.VirtualMachine, encodings)); }
/// <summary> /// convert the bytes from ebcdic to ascii. in the case of an unprintable ascii /// char, insert the hex value of the ebcdic byte in the output text. /// Method is intended for viewing the text value of a byte stream. /// </summary> /// <param name="Bytes"></param> /// <returns></returns> public static string EbcdicBytesToPrintableAscii(this byte[] Bytes) { var sb = new StringBuilder(); global::System.Text.Encoding encoding = global::System.Text.Encoding.GetEncoding(37); var text = encoding.GetString(Bytes); for (int ix = 0; ix < text.Length; ++ix) { var ch1 = text[ix]; if (ch1.IsPrintable()) { sb.Append(ch1); } else { var b1 = Bytes[ix]; var s1 = '/' + b1.ToHex() + ' '; sb.SpaceSeparatorAppend(s1); } } return(sb.ToString()); }
public static NSJSObject New(NSJSVirtualMachine machine, ENCODING encoding) { lock (g_Locker) { if (machine == null || encoding == null) { return(null); } IDictionary <IntPtr, NSJSObject> dVirtualTables; if (!g_EncodingInstanceTable.TryGetValue(encoding.CodePage, out dVirtualTables)) { dVirtualTables = new Dictionary <IntPtr, NSJSObject>(); g_EncodingInstanceTable.Add(encoding.CodePage, dVirtualTables); } NSJSObject o; if (dVirtualTables.TryGetValue(machine.Isolate, out o)) { return(o); } if (!g_UninitializedEncoding) { g_UninitializedEncoding = true; g_GetBytesProc = NSJSPinnedCollection.Pinned <NSJSFunctionCallback>(GetBytes); g_GetStringProc = NSJSPinnedCollection.Pinned <NSJSFunctionCallback>(GetString); } o = NSJSObject.New(machine); o.CrossThreading = true; o.Set("GetBytes", g_GetBytesProc); o.Set("GetString", g_GetStringProc); dVirtualTables.Add(machine.Isolate, o); NSJSKeyValueCollection.Set(o, encoding); return(o); } }
internal void method_12(string string_0, global::System.IO.MemoryStream memoryStream_0) { global::System.Text.Encoding utf = global::System.Text.Encoding.UTF8; byte[] bytes = utf.GetBytes(string_0); this.method_9((short)bytes.Length, memoryStream_0); memoryStream_0.Write(bytes, 0, bytes.Length); }
private static void GetBytes(IntPtr info) { NSJSFunctionCallbackInfo arguments = NSJSFunctionCallbackInfo.From(info); ENCODING encoding = GetEncoding(arguments.This); if (encoding == null) { Throwable.ObjectDisposedException(arguments.VirtualMachine); } else { byte[] buffer = null; if (arguments.Length > 0) { NSJSString s = arguments[0] as NSJSString; if (s != null) { buffer = encoding.GetBytes(s.Value); } } if (buffer == null) { buffer = BufferExtension.EmptryBuffer; } arguments.SetReturnValue(buffer); } }
/// <summary> /// convert the ebcdic encoded input bytes to a unicode string. /// </summary> /// <param name="Bytes"></param> /// <returns></returns> public static string FromEbcdic(this byte[] Bytes) { global::System.Text.Encoding encoding = global::System.Text.Encoding.GetEncoding(37); // 37 = ebcdic var chars = encoding.GetChars(Bytes); return(new string(chars)); }
public static string EbcdicBytesToString(this byte[] Bytes) { global::System.Text.Encoding encoding = global::System.Text.Encoding.GetEncoding(37); var chars = encoding.GetChars(Bytes); return(new string(chars)); }
private static void GetString(IntPtr info) { NSJSFunctionCallbackInfo arguments = NSJSFunctionCallbackInfo.From(info); ENCODING encoding = NSJSKeyValueCollection.Get <ENCODING>(arguments.This); if (encoding == null) { Throwable.ObjectDisposedException(arguments.VirtualMachine); } else { string s = null; if (arguments.Length > 0) { NSJSUInt8Array chars = arguments[0] as NSJSUInt8Array; if (chars != null) { byte[] buffer = chars.Buffer; if (buffer != null) { NSJSInt32 index = null; NSJSInt32 len = null; switch (arguments.Length) { case 2: len = arguments[1] as NSJSInt32; break; case 3: index = arguments[1] as NSJSInt32; len = arguments[2] as NSJSInt32; break; } int ofs = index != null ? index.Value : 0; int count = len != null ? len.Value : buffer.Length; if (count < 0) { count = 0; } if (ofs < 0) { ofs = 0; } s = encoding.GetString(buffer, ofs, count); } } } if (s != null) { arguments.SetReturnValue(s); } else { arguments.SetReturnValue(NSJSValue.Undefined(arguments.VirtualMachine)); } } }
public T FromString(string xml, global::System.Text.Encoding encoding) { MemoryStream ms = new MemoryStream(); byte[] buffer = encoding.GetBytes(xml); ms.Write(buffer, 0, buffer.Length); ms.Position = 0; return(Deserialize(ms)); }
internal string method_7(global::System.IO.Stream stream_0) { ushort num = this.method_3(stream_0); byte[] array = new byte[(int)num]; for (int i = 0; i < (int)num; i++) { byte b = (byte)stream_0.ReadByte(); array[i] = b; } global::System.Text.Encoding utf = global::System.Text.Encoding.UTF8; return(utf.GetString(array)); }
private string method_0(global::System.IO.MemoryStream memoryStream_0) { byte[] array = new byte[2]; memoryStream_0.Read(array, 0, 2); if (global::System.BitConverter.IsLittleEndian) { global::System.Array.Reverse(array); } short num = global::System.BitConverter.ToInt16(array, 0); byte[] array2 = new byte[(int)num]; memoryStream_0.Read(array2, 0, (int)num); global::System.Text.Encoding utf = global::System.Text.Encoding.UTF8; return(utf.GetString(array2)); }
private static void GetEncoding(IntPtr info) { NSJSFunctionCallbackInfo arguments = NSJSFunctionCallbackInfo.From(info); NSJSValue result = null; if (arguments.Length > 0) { NSJSInt32 codepage = arguments[0] as NSJSInt32; try { if (codepage != null) { result = New(arguments.VirtualMachine, ENCODING.GetEncoding(codepage.Value)); } NSJSString name = arguments[0] as NSJSString; if (name != null) { result = New(arguments.VirtualMachine, ENCODING.GetEncoding(name.Value)); } } catch (Exception) { } } arguments.SetReturnValue(NSJSValue.UndefinedMerge(arguments.VirtualMachine, result)); }
/// <summary> /// Initializes a new instance of the <see cref="T:LFNet.Common.IO.StringEncodedWriter" /> class. /// </summary> /// <param name="encoding">The <see cref="T:System.Text.Encoding" /> in which the output is written.</param> /// <param name="sb">The StringBuilder to write to.</param> public StringEncodedWriter(global::System.Text.Encoding encoding, StringBuilder sb) : this(encoding, sb, CultureInfo.CurrentCulture) { }
/// <summary> /// Initializes a new instance of the <see cref="T:LFNet.Common.IO.StringEncodedWriter" /> class. /// </summary> /// <param name="encoding">The <see cref="T:System.Text.Encoding" /> in which the output is written.</param> /// <param name="formatProvider">An <see cref="T:System.IFormatProvider" /> object that controls formatting.</param> public StringEncodedWriter(global::System.Text.Encoding encoding, IFormatProvider formatProvider) : this(encoding, new StringBuilder(), formatProvider) { }
internal static object CreatePrivate(global::System.IO.Stream requestStream, global::System.Security.Cryptography.HashAlgorithm hashAlgorithm, long contentLength, global::System.Text.Encoding encoding, string multipartBoundary, global::Memba.FileUpload.UploadData uploadData) { object[] args = new object[] { requestStream, hashAlgorithm, contentLength, encoding, multipartBoundary, uploadData }; Microsoft.VisualStudio.TestTools.UnitTesting.PrivateObject priv_obj = new Microsoft.VisualStudio.TestTools.UnitTesting.PrivateObject("Memba.FileUpload.XP", "Memba.FileUpload.RequestFilter", new System.Type[] { typeof(global::System.IO.Stream), typeof(global::System.Security.Cryptography.HashAlgorithm), typeof(long), typeof(global::System.Text.Encoding), typeof(string), typeof(global::Memba.FileUpload.UploadData) }, args); return(priv_obj.Target); }
private global::System.IO.MemoryStream InternalSaveDiagram(DslModeling::SerializationResult serializationResult, DslDiagrams::Diagram diagram, string diagramFileName, global::System.Text.Encoding encoding, bool writeOptionalPropertiesWithDefaultValue) { #region Check Parameters global::System.Diagnostics.Debug.Assert(serializationResult != null); global::System.Diagnostics.Debug.Assert(diagram != null); global::System.Diagnostics.Debug.Assert(!serializationResult.Failed); #endregion global::System.IO.MemoryStream newFileContent = new global::System.IO.MemoryStream(); var directory = this.GetDirectory(diagram.Store); DslModeling::SerializationContext serializationContext = new DslModeling::SerializationContext(directory, diagramFileName, serializationResult); this.InitializeSerializationContext(diagram.Partition, serializationContext, false); // MonikerResolver shouldn't be required in Save operation, so not calling SetupMonikerResolver() here. serializationContext.WriteOptionalPropertiesWithDefaultValue = writeOptionalPropertiesWithDefaultValue; global::System.Xml.XmlWriterSettings settings = EFModelSerializationHelper.Instance.CreateXmlWriterSettings(serializationContext, true, encoding); var diagramSerializer = GetSerializer(diagram); using (global::System.Xml.XmlWriter writer = global::System.Xml.XmlWriter.Create(newFileContent, settings)) { //this.WriteRootElement(serializationContext, diagram, writer); // Carry out the normal serialization. this.WriteRootElement(serializationContext, diagramSerializer, diagram, writer); } return(newFileContent); }
internal virtual void SaveDiagrams(DslModeling::SerializationResult serializationResult, DslDiagrams::Diagram[] diagrams, string diagramsFileName, global::System.Text.Encoding encoding, bool writeOptionalPropertiesWithDefaultValue) { #region Check Parameters if (serializationResult == null) { throw new global::System.ArgumentNullException("serializationResult"); } if (diagrams == null) { throw new global::System.ArgumentNullException("diagrams"); } if (string.IsNullOrEmpty(diagramsFileName)) { throw new global::System.ArgumentNullException("diagramsFileName"); } #endregion if (serializationResult.Failed) { return; } var memoryStreamDictionary = new Dictionary <global::System.IO.MemoryStream, string>(); foreach (var diagram in diagrams) { // HACK : Add validation rule on Diagram Name (!string.IsNullOrEmpty && Unique ) if (string.IsNullOrEmpty(diagram.Name)) { throw new ArgumentException("Each diagram must have a name", "diagrams"); } memoryStreamDictionary.Add(this.InternalSaveDiagram(serializationResult, diagram, diagramsFileName, encoding, writeOptionalPropertiesWithDefaultValue), diagram.Name); if (serializationResult.Failed) { memoryStreamDictionary.Keys.ToList <global::System.IO.MemoryStream>().ForEach(memoryStream => memoryStream.Close()); return; } } WriteDiagramFile(diagramsFileName, memoryStreamDictionary); }
/// <summary> /// Creates and returns the settings used when writing a file. /// </summary> /// <param name="serializationContext">The current serialization context instance.</param> /// <param name="isDiagram">Indicates whether a diagram or model file is currently being serialized.</param> /// <param name="encoding">The encoding to use when writing the file.</param> internal virtual global::System.Xml.XmlWriterSettings CreateXmlWriterSettings(DslModeling::SerializationContext serializationContext, bool isDiagram, global::System.Text.Encoding encoding) { global::System.Xml.XmlWriterSettings settings = new global::System.Xml.XmlWriterSettings(); settings.Indent = true; settings.Encoding = encoding; return(settings); }
void IFile.WriteAllText(string path, string contents, global::System.Text.Encoding encoding) { throw new NotImplementedException(); }
string IFile.ReadAllText(string path, global::System.Text.Encoding encoding) { throw new NotImplementedException(); }
public override void SaveModel(DslModeling::SerializationResult serializationResult, MetaModel modelRoot, string fileName, global::System.Text.Encoding encoding, bool writeOptionalPropertiesWithDefaultValue) { base.SaveModel(serializationResult, modelRoot, fileName, encoding, writeOptionalPropertiesWithDefaultValue); System.IO.FileInfo info = new System.IO.FileInfo(fileName); string fileNameDiagram = info.DirectoryName + "\\" + info.Name.Remove(info.Name.Length - info.Extension.Length, info.Extension.Length) + DiagramExtension; // save view information using (global::System.IO.MemoryStream newFileContent = new global::System.IO.MemoryStream()) { DslModeling::DomainXmlSerializerDirectory directory = this.GetDirectory(modelRoot.Store); DslModeling::SerializationContext serializationContext = new DslModeling::SerializationContext(directory, fileName, serializationResult); this.InitializeSerializationContext(modelRoot.Partition, serializationContext, false); // MonikerResolver shouldn't be required in Save operation, so not calling SetupMonikerResolver() here. serializationContext.WriteOptionalPropertiesWithDefaultValue = writeOptionalPropertiesWithDefaultValue; global::System.Xml.XmlWriterSettings settings = LanguageDSLSerializationHelper.Instance.CreateXmlWriterSettings(serializationContext, false, encoding); using (global::System.Xml.XmlWriter writer = global::System.Xml.XmlWriter.Create(newFileContent, settings)) { ViewSerializer serializer = directory.GetSerializer(View.DomainClassId) as ViewSerializer; serializer.Write(serializationContext, modelRoot.View, writer); } if (!serializationResult.Failed && newFileContent != null) { // Only write the content if there's no error encountered during serialization. using (global::System.IO.FileStream fileStream = new global::System.IO.FileStream(fileNameDiagram, global::System.IO.FileMode.Create, global::System.IO.FileAccess.Write, global::System.IO.FileShare.None)) { using (global::System.IO.BinaryWriter writer = new global::System.IO.BinaryWriter(fileStream, encoding)) { writer.Write(newFileContent.ToArray()); } } } } }
private MemoryStream InternalSaveModel2(DslModeling::SerializationResult serializationResult, PatternModelSchema modelRoot, string fileName, global::System.Text.Encoding encoding, bool writeOptionalPropertiesWithDefaultValue) { #region Check Parameters global::System.Diagnostics.Debug.Assert(serializationResult != null); global::System.Diagnostics.Debug.Assert(modelRoot != null); global::System.Diagnostics.Debug.Assert(!serializationResult.Failed); #endregion serializationResult.Encoding = encoding; DslModeling::DomainXmlSerializerDirectory directory = this.GetDirectory(modelRoot.Store); global::System.IO.MemoryStream newFileContent = new global::System.IO.MemoryStream(); DslModeling::SerializationContext serializationContext = new DslModeling::SerializationContext(directory, fileName, serializationResult); this.InitializeSerializationContext(modelRoot.Partition, serializationContext, false); // MonikerResolver shouldn't be required in Save operation, so not calling SetupMonikerResolver() here. serializationContext.WriteOptionalPropertiesWithDefaultValue = writeOptionalPropertiesWithDefaultValue; global::System.Xml.XmlWriterSettings settings = PatternModelSerializationHelper.Instance.CreateXmlWriterSettings(serializationContext, false, encoding); using (global::System.Xml.XmlWriter writer = global::System.Xml.XmlWriter.Create(newFileContent, settings)) { this.WriteRootElement(serializationContext, modelRoot, writer); } return(newFileContent); }
/// <summary> /// Initializes a new instance of the <see cref="T:LFNet.Common.IO.StringEncodedWriter" /> class. /// </summary> /// <param name="encoding">The <see cref="T:System.Text.Encoding" /> in which the output is written.</param> /// <param name="sb">The StringBuilder to write to.</param> /// <param name="formatProvider">An <see cref="T:System.IFormatProvider" /> object that controls formatting.</param> public StringEncodedWriter(global::System.Text.Encoding encoding, StringBuilder sb, IFormatProvider formatProvider) : base(sb, formatProvider) { this._encoding = encoding; }
public virtual void SaveModelAndDiagrams(DslModeling::SerializationResult serializationResult, ModelRoot modelRoot, string modelFileName, DslDiagrams::Diagram[] diagrams, string diagramsFileName, global::System.Text.Encoding encoding, bool writeOptionalPropertiesWithDefaultValue) { #region Check Parameters if (serializationResult == null) { throw new global::System.ArgumentNullException("serializationResult"); } if (string.IsNullOrEmpty(modelFileName)) { throw new global::System.ArgumentNullException("modelFileName"); } if (diagrams == null) { throw new global::System.ArgumentNullException("diagrams"); } if (string.IsNullOrEmpty(diagramsFileName)) { throw new global::System.ArgumentNullException("diagramsFileName"); } #endregion if (serializationResult.Failed) { return; } // Save the model file first var modelFileContent = this.InternalSaveModel(serializationResult, modelRoot, modelFileName, encoding, writeOptionalPropertiesWithDefaultValue); if (serializationResult.Failed) { modelFileContent.Close(); return; } var memoryStreamDictionary = new Dictionary <global::System.IO.MemoryStream, string>(); foreach (var diagram in diagrams) { if (string.IsNullOrEmpty(diagram.Name)) { throw new ArgumentException("Each diagram must have a name", "diagrams"); } memoryStreamDictionary.Add(this.InternalSaveDiagram(serializationResult, diagram, diagramsFileName, encoding, writeOptionalPropertiesWithDefaultValue), diagram.Name); if (serializationResult.Failed) { modelFileContent.Close(); memoryStreamDictionary.Keys.ToList <global::System.IO.MemoryStream>().ForEach(memoryStream => memoryStream.Close()); return; } } // Only write the contents if there's no error encountered during serialization. if (modelFileContent != null) { using (global::System.IO.FileStream fileStream = new global::System.IO.FileStream(modelFileName, global::System.IO.FileMode.Create, global::System.IO.FileAccess.Write, global::System.IO.FileShare.None)) { using (global::System.IO.BinaryWriter writer = new global::System.IO.BinaryWriter(fileStream, encoding)) { writer.Write(modelFileContent.ToArray()); } } } WriteDiagramFile(diagramsFileName, memoryStreamDictionary); }
/// <summary> /// 結合したデータを変換して文字列として返す /// </summary> /// <example> /// string s = builder.Convert(Encoding.GetEncoding("Shift_JIS")); /// </example> /// <param name="CodePage"></param> /// <returns></returns> public string Convert(global::System.Text.Encoding codePage) { return(codePage.GetString(ListHelper <byte> .ConvertToArray(data))); }
/// <summary> /// Saves the diagram. /// </summary> /// <typeparam name="TModel">The type of the model.</typeparam> /// <param name="serializationResult">The serialization result.</param> /// <param name="modelRoot">The model root.</param> /// <param name="modelFileName">Name of the model file.</param> /// <param name="diagram">The diagram.</param> /// <param name="diagramFileName">Name of the diagram file.</param> /// <param name="encoding">The encoding.</param> /// <param name="writeOptionalPropertiesWithDefaultValue">if set to <c>true</c> [write optional properties with default value].</param> public void SaveDiagram <TModel>(DslModeling::SerializationResult serializationResult, TModel modelRoot, string modelFileName, ComponentModelDiagram diagram, string diagramFileName, global::System.Text.Encoding encoding, bool writeOptionalPropertiesWithDefaultValue) where TModel : ModelElement { if (serializationResult.Failed) { return; } // MonikerResolver shouldn't be required in Save operation, so not calling SetupMonikerResolver() here. using (global::System.IO.MemoryStream diagramFileContent = new global::System.IO.MemoryStream()) { DslModeling::DomainClassXmlSerializer diagramSerializer = this.Directory.GetSerializer(diagram.GetDomainClass().Id); global::System.Diagnostics.Debug.Assert(diagramSerializer != null, "Cannot find serializer for " + diagram.GetDomainClass().Name + "!"); if (diagramSerializer != null) { DslModeling::SerializationContext serializationContext = new DslModeling::SerializationContext(this.Directory, diagramFileName, serializationResult); serializationContext.WriteOptionalPropertiesWithDefaultValue = writeOptionalPropertiesWithDefaultValue; global::System.Xml.XmlWriterSettings settings = new global::System.Xml.XmlWriterSettings(); settings.Indent = true; settings.Encoding = encoding; using (global::System.IO.StreamWriter streamWriter = new global::System.IO.StreamWriter(diagramFileContent, encoding)) { using (global::System.Xml.XmlWriter writer = global::System.Xml.XmlWriter.Create(streamWriter, settings)) { diagramSerializer.WriteRootElement(serializationContext, diagram, writer); } } } if (!serializationResult.Failed) { // Only write the contents if there's no error encountered during serialization. if (diagramFileContent != null) { IVsQueryEditQuerySave2 scc = ServiceLocator.Instance.GetService <IVsQueryEditQuerySave2>(typeof(SVsQueryEditQuerySave)); if (scc != null) { uint result; if (scc.QuerySaveFile(diagramFileName, 0, null, out result) != (int)tagVSQuerySaveResult.QSR_SaveOK) { return; } } using (global::System.IO.FileStream fileStream = new global::System.IO.FileStream(diagramFileName, global::System.IO.FileMode.Create, global::System.IO.FileAccess.Write, global::System.IO.FileShare.None)) { using (global::System.IO.BinaryWriter writer = new global::System.IO.BinaryWriter(fileStream, encoding)) { writer.Write(diagramFileContent.ToArray()); } } } } } }