protected internal override void Serialize(IntermediateWriter output, object value, ContentSerializerAttribute format)
        {
            // First serialize the base type.
            if (_baseSerializer != null)
            {
                _baseSerializer.Serialize(output, value, format);
            }

            // Now serialize our own elements.
            foreach (var info in _elements)
            {
                var elementValue = info.Getter(value);

                if (info.Attribute.SharedResource)
                {
                    output.WriteSharedResource(elementValue, info.Attribute);
                }
                else
                {
                    output.WriteObjectInternal(elementValue, info.Attribute, info.Serializer, info.Serializer.TargetType);
                }
            }

            if (_collectionHelper != null)
            {
                _collectionHelper.Serialize(output, value, format);
            }
        }
 public void Serialize(IntermediateWriter output, object collection, ContentSerializerAttribute format)
 {
     var itemFormat = new ContentSerializerAttribute
     {
         ElementName = format.CollectionItemName
     };
     foreach (var item in (IEnumerable)collection)
         output.WriteObject(item, itemFormat, _contentSerializer);
 }
        protected internal override void Serialize(
            IntermediateWriter output, T value, ContentSerializerAttribute format)
        {
            var elements = new List <string>();

            Serialize(value, elements);
            var str = PackedElementsHelper.JoinElements(elements);

            output.Xml.WriteString(str);
        }
        protected internal void Serialize(IntermediateWriter output, List <T> values)
        {
            var elements = new List <string>();

            for (var i = 0; i < values.Count; i++)
            {
                Serialize(values[i], elements);
            }
            var str = PackedElementsHelper.JoinElements(elements);

            output.Xml.WriteString(str);
        }
        protected internal override void Serialize(IntermediateWriter output, Dictionary <TKey, TValue> value, ContentSerializerAttribute format)
        {
            foreach (var kvp in value)
            {
                output.Xml.WriteStartElement(format.CollectionItemName);

                output.WriteObject(kvp.Key, _keyFormat, _keySerializer);
                output.WriteObject(kvp.Value, _valueFormat, _valueSerializer);

                output.Xml.WriteEndElement();
            }
        }
        protected internal override void Serialize(
            IntermediateWriter output, object value, ContentSerializerAttribute format)
        {
            // Create the item serializer attribute.
            var itemFormat = new ContentSerializerAttribute
            {
                ElementName = format.CollectionItemName
            };

            // Read all the items.
            foreach (var item in (IList)value)
            {
                output.WriteObject(item, itemFormat);
            }
        }
        protected internal override void Serialize(
            IntermediateWriter output,
            CurveKeyCollection value,
            ContentSerializerAttribute format)
        {
            var elements = new List <string>();

            foreach (var curveKey in value)
            {
                // Order: Position, Value, TangentIn, TangentOut and Continuity
                elements.Add(XmlConvert.ToString(curveKey.Position));
                elements.Add(XmlConvert.ToString(curveKey.Value));
                elements.Add(XmlConvert.ToString(curveKey.TangentIn));
                elements.Add(XmlConvert.ToString(curveKey.TangentOut));
                elements.Add(curveKey.Continuity.ToString());
            }
            var str = PackedElementsHelper.JoinElements(elements);

            output.Xml.WriteString(str);
        }
        protected internal override void Serialize(IntermediateWriter output, List <T> value, ContentSerializerAttribute format)
        {
            if (_itemSerializer is ElementSerializer <T> elementSerializer)
            {
                elementSerializer.Serialize(output, value);
            }
            else
            {
                // Create the item serializer attribute.
                var itemFormat = new ContentSerializerAttribute
                {
                    ElementName = format.CollectionItemName
                };

                // Read all the items.
                foreach (var item in value)
                {
                    output.WriteObject(item, itemFormat, _itemSerializer);
                }
            }
        }
        public static void Serialize <T>(XmlWriter output, T value, string referenceRelocationPath)
        {
            var serializer = new IntermediateSerializer();
            var writer     = new IntermediateWriter(serializer, output, referenceRelocationPath);

            output.WriteStartElement("XnaContent");

            serializer._namespaceAliasHelper.WriteNamespaces(output, value);

            // Write the asset.
            var format = new ContentSerializerAttribute {
                ElementName = "Asset"
            };

            writer.WriteObject <object>(value, format);

            // Process the shared resources and external references.
            writer.WriteSharedResources();
            writer.WriteExternalReferences();

            // Close the XnaContent element.
            output.WriteEndElement();
        }
Exemple #10
0
 protected internal override void Serialize(IntermediateWriter output, object value, ContentSerializerAttribute format)
 {
     Debug.Assert(value.GetType() == TargetType, "Got invalid value type!");
     output.Xml.WriteString(value.ToString());
 }
Exemple #11
0
 protected internal override void Serialize(IntermediateWriter output, T?value, ContentSerializerAttribute format)
 {
     output.WriteRawObject(value.Value, _format, _serializer);
 }
        protected internal override void Serialize(IntermediateWriter output, object value, ContentSerializerAttribute format)
        {
            var cast = value == null ? default : (T)value;

                       Serialize(output, cast, format);
        }
 protected internal abstract void Serialize(IntermediateWriter output, T value, ContentSerializerAttribute format);
Exemple #14
0
 protected internal override void Serialize(IntermediateWriter output, T[] value, ContentSerializerAttribute format)
 {
     _listSerializer.Serialize(output, new List <T>(value), format);
 }
 protected internal override void Serialize(IntermediateWriter output, ExternalReference <T> value, ContentSerializerAttribute format)
 {
     output.WriteExternalReference(value);
 }