public void WriteExternal(IPofWriter writer)
{
writer.WriteInt32(0, INTEGER);
IPofWriter nested1 = writer.CreateNestedPofWriter(1);
IPofWriter nested2 = nested1.CreateNestedPofWriter(0);
nested2.WriteString(0, STRING);
nested2.WriteObject(1, PERSON);
nested2.WriteDoubleArray(2, DOUBLE_ARRAY);
IPofWriter nested3 = nested2.CreateNestedPofWriter(3);
nested3.WriteArray(0, STRING_ARRAY, typeof(String));
nested2.WriteBoolean(4, false);
nested2.WriteRemainder(null);
nested1.WriteCollection(1, (ICollection <String>)set);
nested1.WriteDouble(2, 2.0);
nested1.WriteInt32(3, 5);
nested1.WriteCollection(4, set, typeof(String));
nested1.WriteObject(5, PERSON);
nested1.WriteDouble(10, 2.222);
writer.WriteDouble(2, 4.444);
writer.WriteInt32(3, 15);
writer.WriteObject(4, PERSON);
}
public void Serialize(IPofWriter pofWriter, object o)
{
var p = (Product)o;
pofWriter.WriteObject(0, p.getBalance());
pofWriter.WriteRemainder(null);
}
/// <summary>
/// Serialize a user type instance to a POF stream by writing its
/// state using the specified <see cref="IPofWriter"/> object.
/// </summary>
/// <param name="writer">
/// The <b>IPofWriter</b> with which to write the object's state.
/// </param>
/// <param name="o">
/// The object to serialize.
/// </param>
/// <exception cref="IOException">
/// If an I/O error occurs.
/// </exception>
public void Serialize(IPofWriter writer, object o)
{
try
{
StringBuilder sb = new StringBuilder();
using (TextWriter txtWriter = new StringWriter(sb))
{
new System.Xml.Serialization.XmlSerializer(o.GetType()).Serialize(txtWriter, o);
}
writer.WriteString(0, sb.ToString());
writer.WriteRemainder(null);
}
catch (InvalidOperationException e)
{
string typeName = null;
try
{
typeName = writer.PofContext.GetTypeName(m_typeId);
}
catch (Exception)
{}
string actual = o.GetType().FullName;
throw new IOException(
"An exception occurred writing an object"
+ " user type to a POF stream: type-id=" + m_typeId
+ (typeName == null ? "" : ", class-name=" + typeName)
+ (actual == null ? "" : ", actual class-name=" + actual)
+ ", exception=\n" + e);
}
}
/// <summary>
/// Serialize a user type instance to a POF stream by writing its
/// state using the specified <see cref="IPofWriter"/> object.
/// </summary>
/// <remarks>
/// An implementation of <b>IPofSerializer</b> is required to follow
/// the following steps in sequence for writing out an object of a
/// user type:
/// <list type="number">
/// <item>
/// <description>
/// The implementation may write any combination of the properties of
/// the user type by using the "write" methods of the
/// <b>IPofWriter</b>, but it must do so in the order of the property
/// indexes.
/// </description>
/// </item>
/// <item>
/// <description>
/// After all desired properties of the user type have been written,
/// the implementation must terminate the writing of the user type by
/// calling <see cref="IPofWriter.WriteRemainder"/>.
/// </description>
/// </item>
/// </list>
/// </remarks>
/// <param name="writer">
/// The <b>IPofWriter</b> with which to write the object's state.
/// </param>
/// <param name="o">
/// The object to serialize.
/// </param>
/// <exception cref="IOException">
/// If an I/O error occurs.
/// </exception>
public void Serialize(IPofWriter writer, object o)
{
MemoryStream stream = new MemoryStream();
try
{
new BinaryFormatter().Serialize(stream, o);
stream.Position = 0;
writer.WriteObject(0, stream.GetBuffer());
writer.WriteRemainder(null);
}
catch (SerializationException e)
{
string typeName = null;
try
{
typeName = writer.PofContext.GetTypeName(m_typeId);
}
catch (Exception)
{ }
string actual = o.GetType().FullName;
throw new IOException(
"An exception occurred writing an object"
+ " user type to a POF stream: type-id=" + m_typeId
+ (typeName == null ? "" : ", class-name=" + typeName)
+ (actual == null ? "" : ", actual class-name=" + actual)
+ ", exception=\n" + e);
}
finally
{
stream.Close();
}
}
/// <summary>
/// Serialize a user type instance to a POF stream by writing its
/// state using the specified <see cref="IPofWriter"/> object.
/// </summary>
/// <remarks>
/// An implementation of <b>IPofSerializer</b> is required to follow
/// the following steps in sequence for writing out an object of a
/// user type:
/// <list type="number">
/// <item>
/// <description>
/// If the object is evolvable, the implementation must set the
/// version by calling <see cref="IPofWriter.VersionId"/>.
/// </description>
/// </item>
/// <item>
/// <description>
/// The implementation may write any combination of the properties of
/// the user type by using the "write" methods of the
/// <b>IPofWriter</b>, but it must do so in the order of the property
/// indexes.
/// </description>
/// </item>
/// <item>
/// <description>
/// After all desired properties of the user type have been written,
/// the implementation must terminate the writing of the user type by
/// calling <see cref="IPofWriter.WriteRemainder"/>.
/// </description>
/// </item>
/// </list>
/// </remarks>
/// <param name="writer">
/// The <b>IPofWriter</b> with which to write the object's state.
/// </param>
/// <param name="o">
/// The object to serialize.
/// </param>
/// <exception cref="IOException">
/// If an I/O error occurs.
/// </exception>
public void Serialize(IPofWriter writer, object o)
{
IIdentity identity = (IIdentity)o;
writer.WriteString(0, identity.Name);
writer.WriteRemainder(null);
}
/// <summary>
/// Serialize a user type instance to a POF stream by writing its
/// state using the specified <see cref="IPofWriter"/> object.
/// </summary>
/// <remarks>
/// An implementation of <b>IPofSerializer</b> is required to follow
/// the following steps in sequence for writing out an object of a
/// user type:
/// <list type="number">
/// <item>
/// <description>
/// If the object is evolvable, the implementation must set the
/// version by calling <see cref="IPofWriter.VersionId"/>.
/// </description>
/// </item>
/// <item>
/// <description>
/// The implementation may write any combination of the properties of
/// the user type by using the "write" methods of the
/// <b>IPofWriter</b>, but it must do so in the order of the property
/// indexes.
/// </description>
/// </item>
/// <item>
/// <description>
/// After all desired properties of the user type have been written,
/// the implementation must terminate the writing of the user type by
/// calling <see cref="IPofWriter.WriteRemainder"/>.
/// </description>
/// </item>
/// </list>
/// </remarks>
/// <param name="writer">
/// The <b>IPofWriter</b> with which to write the object's state.
/// </param>
/// <param name="o">
/// The object to serialize.
/// </param>
/// <exception cref="IOException">
/// If an I/O error occurs.
/// </exception>
public virtual void Serialize(IPofWriter writer, object o)
{
// set the version identifier
bool isEvolvable = o is IEvolvable;
IEvolvable evolvable = null;
if (isEvolvable)
{
evolvable = (IEvolvable)o;
writer.VersionId =
Math.Max(evolvable.DataVersion, evolvable.ImplVersion);
}
// POF Annotation processing
for (IEnumerator enmr = m_tmd.GetAttributes(); enmr.MoveNext();)
{
IAttributeMetadata <object> attr = (IAttributeMetadata <object>)enmr.Current;
attr.Codec.Encode(writer, attr.Index, attr.Get(o));
}
// write out any future properties
Binary remainder = null;
if (isEvolvable)
{
remainder = evolvable.FutureData;
}
writer.WriteRemainder(remainder);
}
public void WriteExternal(IPofWriter writer)
{
writer.WriteInt32(0, INTEGER);
IPofWriter nested1 = writer.CreateNestedPofWriter(1);
IPofWriter nested2 = nested1.CreateNestedPofWriter(0);
nested2.WriteString(0, STRING);
nested2.WriteSingleArray(2, FLOAT_ARRAY);
IPofWriter nested3 = nested2.CreateNestedPofWriter(3);
nested3.WriteArray(0, STRING_ARRAY, typeof(String));
nested2.WriteBoolean(4, false);
nested2.WriteRemainder(null);
IList list = (IList)set;
nested1.WriteCollection(1, list);
nested1.WriteDouble(2, 2.0);
nested1.WriteInt32(3, 5);
nested1.WriteCollection(4, set);
nested1.WriteDouble(10, 2.222);
writer.WriteDouble(2, 4.444);
writer.WriteInt32(3, 15);
}
public void Serialize(IPofWriter pofWriter, object o)
{
var bal = (Balance)o;
pofWriter.WriteDouble(0, bal.getBalance());
pofWriter.WriteObject(1, bal.getCustomer());
pofWriter.WriteRemainder(null);
}
public void Serialize(IPofWriter pofWriter, object o)
{
var c = (Customer)o;
pofWriter.WriteString(0, c.getName());
pofWriter.WriteObject(1, c.getProduct());
pofWriter.WriteObject(2, c.getBalance());
pofWriter.WriteRemainder(null);
}
/// <summary>
/// Serialize a user type instance to a POF stream by writing its
/// state using the specified <see cref="IPofWriter"/> object.
/// </summary>
/// <remarks>
/// An implementation of <b>IPofSerializer</b> is required to follow
/// the following steps in sequence for writing out an object of a
/// user type:
/// <list type="number">
/// <item>
/// <description>
/// If the object is evolvable, the implementation must set the
/// version by calling <see cref="IPofWriter.VersionId"/>.
/// </description>
/// </item>
/// <item>
/// <description>
/// The implementation may write any combination of the properties of
/// the user type by using the "write" methods of the
/// <b>IPofWriter</b>, but it must do so in the order of the property
/// indexes.
/// </description>
/// </item>
/// <item>
/// <description>
/// After all desired properties of the user type have been written,
/// the implementation must terminate the writing of the user type by
/// calling <see cref="IPofWriter.WriteRemainder"/>.
/// </description>
/// </item>
/// </list>
/// </remarks>
/// <param name="writer">
/// The <b>IPofWriter</b> with which to write the object's state.
/// </param>
/// <param name="o">
/// The object to serialize.
/// </param>
/// <exception cref="IOException">
/// If an I/O error occurs.
/// </exception>
public void Serialize(IPofWriter writer, object o)
{
IPrincipal principal = (IPrincipal)o;
IList identities = new ArrayList(1);
identities.Add(principal.Identity);
writer.WriteCollection(0, identities);
writer.WriteRemainder(null);
}
/// <summary>
/// Serialize an enum instance to a POF stream by writing its
/// value using the specified <see cref="IPofWriter"/> object.
/// </summary>
/// <param name="writer">
/// The <b>IPofWriter</b> with which to write the object's state.
/// </param>
/// <param name="o">
/// The object to serialize.
/// </param>
/// <exception cref="IOException">
/// If an I/O error occurs.
/// </exception>
public void Serialize(IPofWriter writer, object o)
{
if (o == null || !o.GetType().IsEnum)
{
throw new ArgumentException(
"EnumPofSerializer can only be used to serialize enum types.");
}
writer.WriteString(0, o.ToString());
writer.WriteRemainder(null);
}
/// <summary>
/// Serialize a user type instance to a POF stream by writing its
/// state using the specified <see cref="IPofWriter"/> object.
/// </summary>
/// <remarks>
/// An implementation of <b>IPofSerializer</b> is required to follow
/// the following steps in sequence for writing out an object of a
/// user type:
/// <list type="number">
/// <item>
/// <description>
/// If the object is evolvable, the implementation must set the
/// version by calling <see cref="IPofWriter.VersionId"/>.
/// </description>
/// </item>
/// <item>
/// <description>
/// The implementation may write any combination of the properties of
/// the user type by using the "write" methods of the
/// <b>IPofWriter</b>, but it must do so in the order of the property
/// indexes.
/// </description>
/// </item>
/// <item>
/// <description>
/// After all desired properties of the user type have been written,
/// the implementation must terminate the writing of the user type by
/// calling <see cref="IPofWriter.WriteRemainder"/>.
/// </description>
/// </item>
/// </list>
/// </remarks>
/// <param name="writer">
/// The <see cref="IPofWriter"/> with which to write the object's
/// state.
/// </param>
/// <param name="o">
/// The object to serialize.
/// </param>
/// <exception cref="IOException">
/// If an I/O error occurs.
/// </exception>
public virtual void Serialize(IPofWriter writer, object o)
{
IPortableObject portable;
try
{
portable = (IPortableObject)o;
}
catch (InvalidCastException e)
{
string typeName = null;
try
{
typeName = writer.PofContext.GetTypeName(m_typeId);
}
catch (Exception)
{}
string actual = o.GetType().FullName;
throw new IOException(
"An exception occurred writing an IPortableObject"
+ " user type to a POF stream: type-id=" + m_typeId
+ (typeName == null ? "" : ", class-name=" + typeName)
+ (actual == null ? "" : ", actual class-name=" + actual)
+ ", exception=\n" + e);
}
// set the version identifier
bool isEvolvable = portable is IEvolvable;
IEvolvable evolvable = null;
if (isEvolvable)
{
evolvable = (IEvolvable)portable;
writer.VersionId =
Math.Max(evolvable.DataVersion, evolvable.ImplVersion);
}
// write out the object's properties
portable.WriteExternal(writer);
// write out any future properties
Binary remainder = null;
if (isEvolvable)
{
remainder = evolvable.FutureData;
}
writer.WriteRemainder(remainder);
}
/// <summary>
/// Serialize a user type instance to a POF stream by writing its
/// state using the specified <see cref="IPofWriter"/> object.
/// </summary>
/// <remarks>
/// An implementation of <b>IPofSerializer</b> is required to follow
/// the following steps in sequence for writing out an object of a
/// user type:
/// <list type="number">
/// <item>
/// <description>
/// If the object is evolvable, the implementation must set the
/// version by calling <see cref="IPofWriter.VersionId"/>.
/// </description>
/// </item>
/// <item>
/// <description>
/// The implementation may write any combination of the properties of
/// the user type by using the "write" methods of the
/// <b>IPofWriter</b>, but it must do so in the order of the property
/// indexes.
/// </description>
/// </item>
/// <item>
/// <description>
/// After all desired properties of the user type have been written,
/// the implementation must terminate the writing of the user type by
/// calling <see cref="IPofWriter.WriteRemainder"/>.
/// </description>
/// </item>
/// </list>
/// </remarks>
/// <param name="writer">
/// The <b>IPofWriter</b> with which to write the object's state.
/// </param>
/// <param name="o">
/// The object to serialize.
/// </param>
/// <exception cref="IOException">
/// If an I/O error occurs.
/// </exception>
public void Serialize(IPofWriter writer, Object o)
{
var buffer = new BinaryMemoryStream(1024 * 8);
PofStreamWriter userTypeWriter = new PofStreamWriter.UserTypeWriter(
new DataWriter(buffer), m_pofContext, TYPE_PORTABLE, -1);
// COH-5065: due to the complexity of maintaining references
// in future data, we won't support them for IEvolvable objects
if (m_pofContext.IsReferenceEnabled && !(o is IEvolvable))
{
userTypeWriter.EnableReference();
}
m_serializer.Serialize(userTypeWriter, o);
String typeName = o.GetType().AssemblyQualifiedName;
writer.WriteString(0, typeName);
writer.WriteBinary(1, buffer.ToBinary());
writer.WriteRemainder(null);
Register(typeName);
}
/// <summary>
/// Serialize a user type instance to a POF stream by writing its
/// state using the specified <see cref="IPofWriter"/> object.
/// </summary>
/// <remarks>
/// An implementation of <b>IPofSerializer</b> is required to follow
/// the following steps in sequence for writing out an object of a
/// user type:
/// <list type="number">
/// <item>
/// <description>
/// If the object is evolvable, the implementation must set the
/// version by calling <see cref="IPofWriter.VersionId"/>.
/// </description>
/// </item>
/// <item>
/// <description>
/// The implementation may write any combination of the properties of
/// the user type by using the "write" methods of the
/// <b>IPofWriter</b>, but it must do so in the order of the property
/// indexes.
/// </description>
/// </item>
/// <item>
/// <description>
/// After all desired properties of the user type have been written,
/// the implementation must terminate the writing of the user type by
/// calling <see cref="IPofWriter.WriteRemainder"/>.
/// </description>
/// </item>
/// </list>
/// </remarks>
/// <param name="writer">
/// The <b>IPofWriter</b> with which to write the object's state.
/// </param>
/// <param name="o">
/// The object to serialize.
/// </param>
/// <exception cref="IOException">
/// If an I/O error occurs.
/// </exception>
public void Serialize(IPofWriter writer, Object o)
{
writer.WriteBinary(0, ToBinary(o, m_serializer));
writer.WriteRemainder(null);
Register(o);
}
/// <see cref="IPofSerializer"/>
void IPofSerializer.Serialize(IPofWriter writer, object o)
{
writer.WriteCollection(0, (HashSet)o);
writer.WriteRemainder(null);
}
/// <summary>
/// Serialize a user type instance to a POF stream by writing its
/// state using the specified <see cref="IPofWriter"/> object.
/// </summary>
/// <remarks>
/// An implementation of <b>IPofSerializer</b> is required to follow
/// the following steps in sequence for writing out an object of a
/// user type:
/// <list type="number">
/// <item>
/// <description>
/// If the object is evolvable, the implementation must set the
/// version by calling <see cref="IPofWriter.VersionId"/>.
/// </description>
/// </item>
/// <item>
/// <description>
/// The implementation may write any combination of the properties of
/// the user type by using the "write" methods of the
/// <b>IPofWriter</b>, but it must do so in the order of the property
/// indexes.
/// </description>
/// </item>
/// <item>
/// <description>
/// After all desired properties of the user type have been written,
/// the implementation must terminate the writing of the user type by
/// calling <see cref="IPofWriter.WriteRemainder"/>.
/// </description>
/// </item>
/// </list>
/// </remarks>
/// <param name="pofWriter">
/// The <b>IPofWriter</b> with which to write the object's state.
/// </param>
/// <param name="o">
/// The object to serialize.
/// </param>
/// <exception cref="IOException">
/// If an I/O error occurs.
/// </exception>
public void Serialize(IPofWriter pofWriter, Object o)
{
if (!(o is IPortableObject))
{
throw new IOException("Class [" + o.GetType() +
"] does not implement a IPortableObject interface");
}
IPortableObject po = (IPortableObject)o;
bool fEvolvable = o is IEvolvableObject;
IEvolvableObject et = fEvolvable ? (IEvolvableObject)o : null;
try
{
CacheFactory.Log("Serializing " + o.GetType(), CacheFactory.LogLevel.Max);
IPofContext ctx = pofWriter.PofContext;
IEnumerable <int> typeIds = GetTypeIds(o, ctx);
foreach (int typeId in typeIds)
{
IEvolvable e = null;
if (fEvolvable)
{
e = et.GetEvolvable(typeId);
}
IPofWriter writer = pofWriter.CreateNestedPofWriter(typeId, typeId);
if (fEvolvable)
{
writer.VersionId = Math.Max(e.DataVersion, e.ImplVersion);
}
Type type = GetTypeForTypeId(ctx, typeId);
if (type != null)
{
po.WriteExternal(writer);
}
writer.WriteRemainder(fEvolvable ? e.FutureData : null);
}
pofWriter.WriteRemainder(null);
}
catch (Exception e)
{
String sClass = null;
try
{
sClass = pofWriter.PofContext.GetTypeName(m_nTypeId);
}
catch (Exception)
{
}
String sActual = null;
try
{
sActual = o.GetType().FullName;
}
catch (Exception)
{
}
throw new IOException(
"An exception occurred writing a IPortableObject"
+ " user type to a POF stream: type-id=" + m_nTypeId
+ (sClass == null ? "" : ", class-name=" + sClass)
+ (sActual == null ? "" : ", actual class-name=" + sActual)
+ ", exception=" + e, e);
}
}
/// <summary>
/// Serialize a user type instance to a POF stream by writing its
/// state using the specified <see cref="IPofWriter"/> object.
/// </summary>
/// <remarks>
/// An implementation of <b>IPofSerializer</b> is required to follow
/// the following steps in sequence for writing out an object of a
/// user type:
/// <list type="number">
/// <item>
/// <description>
/// If the object is evolvable, the implementation must set the
/// version by calling <see cref="IPofWriter.VersionId"/>.
/// </description>
/// </item>
/// <item>
/// <description>
/// The implementation may write any combination of the properties of
/// the user type by using the "write" methods of the
/// <b>IPofWriter</b>, but it must do so in the order of the property
/// indexes.
/// </description>
/// </item>
/// <item>
/// <description>
/// After all desired properties of the user type have been written,
/// the implementation must terminate the writing of the user type by
/// calling <see cref="IPofWriter.WriteRemainder"/>.
/// </description>
/// </item>
/// </list>
/// </remarks>
/// <param name="writer">
/// The <b>IPofWriter</b> with which to write the object's state.
/// </param>
/// <param name="o">
/// The object to serialize.
/// </param>
/// <exception cref="IOException">
/// If an I/O error occurs.
/// </exception>
public void Serialize(IPofWriter writer, object o)
{
WriteException(writer, (Exception)o);
writer.WriteRemainder(null);
}
