/// <summary> /// Serializes a static <see cref="StreamOutputElement"/>. /// </summary> /// <param name="value">The <see cref="StreamOutputElement"/> to serialize</param> /// <param name="serializeFlags">Type of serialization, see <see cref="SerializeFlags"/>.</param> /// <remarks> /// Note that depending on the serialization <see cref="Mode"/>, this method reads or writes the value. /// </remarks> public void Serialize(ref StreamOutputElement value, SerializeFlags serializeFlags = SerializeFlags.Normal) { int storeObjectRef; if (SerializeIsNull(ref value, out storeObjectRef, serializeFlags)) { return; } if (Mode == SerializerMode.Read) { value = new StreamOutputElement(); } // Store ObjectRef if (storeObjectRef >= 0) { StoreObjectRef(value, storeObjectRef); } Serialize(ref value.Stream); Serialize(ref value.SemanticName); Serialize(ref value.SemanticIndex); Serialize(ref value.StartComponent); Serialize(ref value.ComponentCount); Serialize(ref value.OutputSlot); }
// Creates the serializer memory stream if it hasn't been already, // and initializes the serialization flags private void InitSerializer(SerializeFlags flags) { _AltSerializer.Stream = _MemStream; _AltSerializer.SerializePropertyNames = ((flags & SerializeFlags.SerializePropertyNames) != 0); _AltSerializer.CacheEnabled = ((flags & SerializeFlags.SerializationCache) != 0); _AltSerializer.SerializeProperties = ((flags & SerializeFlags.SerializeProperties) != 0); }
/// <summary> /// Serializes an array of static <see cref="StreamOutputElement"/>s. /// </summary> /// <param name="valueArray">An array of <see cref="StreamOutputElement"/>s to serialize</param> /// <param name="serializeFlags">Type of serialization, see <see cref="SerializeFlags"/>.</param> /// <remarks> /// Note that depending on the serialization <see cref="Mode"/>, this method reads or writes the value. /// </remarks> public void Serialize(ref StreamOutputElement[] valueArray, SerializeFlags serializeFlags = SerializeFlags.Normal) { int storeObjectRef; if (SerializeIsNull(ref valueArray, out storeObjectRef, serializeFlags)) return; if (Mode == SerializerMode.Write) { // Store ObjectRef if (storeObjectRef >= 0) StoreObjectRef(valueArray, storeObjectRef); WriteArrayLength(valueArray.Length); for (int i = 0; i < valueArray.Length; i++) Serialize(ref valueArray[i], serializeFlags); } else { var count = ReadArrayLength(); valueArray = new StreamOutputElement[count]; // Store ObjectRef if (storeObjectRef >= 0) StoreObjectRef(valueArray, storeObjectRef); for (int index = 0; index < count; index++) Serialize(ref valueArray[index], serializeFlags); } }
public void PrintTo(object val, string entryName, string file, SerializeFlags DataFlags = SerializeFlags.None) { currentFlags = DataFlags; using (writter = new Writter(file)) { Print(val, entryName); } }
public string PrintToString(object val, string entryName, SerializeFlags DataFlags = SerializeFlags.None) { currentFlags = DataFlags; using (writter = new Writter()) { Print(val, entryName); return(writter.GetString()); } }
/// <summary> /// Deserializes an object and returns the result. /// </summary> /// <param name="bytes">Array of bytes containing the serialized object.</param> /// <param name="objectType">The object type contained in the serialized byte array.</param> /// /// <param name="flags">Flags to control the deserialization.</param> /// <returns>Returns the deserialized object.</returns> public object Deserialize(byte[] bytes, Type objectType, SerializeFlags flags) { object returnValue; lock (_AltSerializer) { InitSerializer(flags); MemoryStream objectStream = new MemoryStream(bytes); _AltSerializer.Reset(); _AltSerializer.Stream = objectStream; returnValue = _AltSerializer.Deserialize(objectType); _AltSerializer.Stream = _MemStream; objectStream.Dispose(); } return(returnValue); }
/// <summary> /// Serializes buffer into a textual representation of its glyph content, useful for showing the contents /// of the buffer, for example during debugging. There are currently two supported serialization formats. /// </summary> /// <param name="start">the first item in buffer to serialize.</param> /// <param name="end"> /// thought the official manual says it's "the last item in buffer to serialize", it looks more like /// "actual running length of items to serialize" to me. /// </param> /// <param name="bufferSize">the size of unmanaged buffer for receiving the serialized string.</param> /// <param name="format">the <see cref="SerializeFormat" /> to use for formatting the output.</param> /// <param name="flags">the <see cref="SerializeFlags" /> that control what glyph properties to serialize.</param> /// <param name="font"> /// the <see cref="Font" /> used to shape this buffer, needed to read glyph names and extents. If NULL, /// and empty font will be used. /// </param> public string Serialize(uint start, uint end, uint bufferSize, Tag format, SerializeFlags flags = SerializeFlags.Default, Font.Font font = null) { var buffer = Marshal.AllocHGlobal((int)bufferSize); try { Api.hb_buffer_serialize_glyphs(Handle, start, end, buffer, bufferSize, out var consumed, font?.Handle ?? IntPtr.Zero, format, flags); return(Marshal.PtrToStringAnsi(buffer, (int)consumed)); } finally { Marshal.FreeHGlobal(buffer); } }
/// <summary> /// Serializes a static <see cref="StreamOutputElement"/>. /// </summary> /// <param name="value">The <see cref="StreamOutputElement"/> to serialize</param> /// <param name="serializeFlags">Type of serialization, see <see cref="SerializeFlags"/>.</param> /// <remarks> /// Note that depending on the serialization <see cref="Mode"/>, this method reads or writes the value. /// </remarks> public void Serialize(ref StreamOutputElement value, SerializeFlags serializeFlags = SerializeFlags.Normal) { int storeObjectRef; if (SerializeIsNull(ref value, out storeObjectRef, serializeFlags)) return; if (Mode == SerializerMode.Read) value = new StreamOutputElement(); // Store ObjectRef if (storeObjectRef >= 0) StoreObjectRef(value, storeObjectRef); Serialize(ref value.Stream); Serialize(ref value.SemanticName); Serialize(ref value.SemanticIndex); Serialize(ref value.StartComponent); Serialize(ref value.ComponentCount); Serialize(ref value.OutputSlot); }
/// <summary> /// Serializes an array of static <see cref="StreamOutputElement"/>s. /// </summary> /// <param name="valueArray">An array of <see cref="StreamOutputElement"/>s to serialize</param> /// <param name="serializeFlags">Type of serialization, see <see cref="SerializeFlags"/>.</param> /// <remarks> /// Note that depending on the serialization <see cref="Mode"/>, this method reads or writes the value. /// </remarks> public void Serialize(ref StreamOutputElement[] valueArray, SerializeFlags serializeFlags = SerializeFlags.Normal) { int storeObjectRef; if (SerializeIsNull(ref valueArray, out storeObjectRef, serializeFlags)) { return; } if (Mode == SerializerMode.Write) { // Store ObjectRef if (storeObjectRef >= 0) { StoreObjectRef(valueArray, storeObjectRef); } WriteArrayLength(valueArray.Length); for (int i = 0; i < valueArray.Length; i++) { Serialize(ref valueArray[i], serializeFlags); } } else { var count = ReadArrayLength(); valueArray = new StreamOutputElement[count]; // Store ObjectRef if (storeObjectRef >= 0) { StoreObjectRef(valueArray, storeObjectRef); } for (int index = 0; index < count; index++) { Serialize(ref valueArray[index], serializeFlags); } } }
public static extern uint hb_buffer_serialize_glyphs(IntPtr buffer, uint start, uint end, IntPtr buf, uint buf_size, out uint buf_consumed, IntPtr font, Tag format, SerializeFlags flags);
public void PrintTo(object val, string entryName, Stream stream, SerializeFlags DataFlags = SerializeFlags.None) { writter = new Writter(stream); currentFlags = DataFlags; Print(val, entryName); }
bool HasFlag(SerializeFlags flag) { return((currentFlags & flag) == flag); }
public ExtendAttribute(SerializeFlags flags) { Flags = flags; }