/// <summary>
///
/// </summary>
/// <param name="obj"></param>
/// <param name="writer"></param>
/// <param name="state"></param>
public override void Serialize(object obj, XmlWriter writer, SerializationState state)
{
foreach (object item in (IList)obj)
{
ListItem listItem;
listItem = (ListItem)m_TypeToItemMap[item.GetType()];
writer.WriteStartElement(listItem.Alias);
if (listItem.Attribute != null &&
listItem.Attribute.SerializeAsValueNode &&
listItem.Attribute.ValueNodeAttributeName != null &&
listItem.Serializer is TypeSerializerWithSimpleTextSupport)
{
writer.WriteAttributeString(listItem.Attribute.ValueNodeAttributeName,
((TypeSerializerWithSimpleTextSupport)listItem.Serializer).Serialize(item, state));
}
else
{
listItem.Serializer.Serialize(item, writer, state);
}
writer.WriteEndElement();
}
}
/// <summary>
/// Encrypts the specified plain text.
/// </summary>
/// <param name="plainText">The plain text.</param>
/// <param name="credentialName">
/// The name of the credential to use for this encryption operation,
/// or null to use the default credential.
/// </param>
/// <param name="serializationState">
/// An object that holds an arbitrary value that is passed to one or more encrypt
/// operations within a single serialization operation.
/// </param>
/// <returns>The encrypted text.</returns>
public string Encrypt(string plainText, string credentialName, SerializationState serializationState)
{
var encryptor = serializationState.Get(() => _crypto.GetEncryptor(credentialName?.ToString()));
var cipherText = encryptor.Encrypt(plainText);
return(cipherText);
}
public override SerializationState GetObjectState()
{
var state = new SerializationState(this);
state.AddValue("race_name", RaceName);
return(state);
}
/// <summary>
/// Decrypts the specified cipher text.
/// </summary>
/// <param name="cipherText">The cipher text.</param>
/// <param name="credentialName">
/// The name of the credential to use for this encryption operation,
/// or null to use the default credential.
/// </param>
/// <param name="serializationState">
/// An object that holds an arbitrary value that is passed to one or more decrypt
/// operations within a single serialization operation.
/// </param>
/// <returns>The decrypted text.</returns>
public string Decrypt(string cipherText, string credentialName, SerializationState serializationState)
{
var decryptor = serializationState.Get(() => _crypto.GetDecryptor(credentialName?.ToString()));
var plainText = decryptor.Decrypt(cipherText);
return(plainText);
}
private static void WriteNullFillers(SerializationState state, UInt32 nullCount)
{
if (nullCount > 0)
{
if (nullCount > 1)
{
var useByte = nullCount <= Byte.MaxValue;
state.EnsureCapacity(useByte ? 2 : 5);
state.array.WriteByteToBytes(ref state.idx, (Byte)(useByte ? RecordTypeEnumeration.ObjectNullMultiple256 : RecordTypeEnumeration.ObjectNullMultiple));
if (useByte)
{
state.array.WriteByteToBytes(ref state.idx, (Byte)nullCount);
}
else
{
state.array.WriteUInt32LEToBytes(ref state.idx, nullCount);
}
}
else
{
// Just write one null
state.EnsureCapacity(1);
state.array.WriteByteToBytes(ref state.idx, (Byte)RecordTypeEnumeration.ObjectNull);
}
state.WriteArrayToStream();
}
}
public static void WriteNRBFRecords(this IList <AbstractRecord> records, Stream stream)
{
var state = new SerializationState(stream);
// Write header
state.EnsureCapacity(17); // Header + header value
state.array
.WriteByteToBytes(ref state.idx, (Byte)RecordTypeEnumeration.SerializedStreamHeader)
.WriteInt32LEToBytes(ref state.idx, 1)
.WriteInt32LEToBytes(ref state.idx, -1)
.WriteInt32LEToBytes(ref state.idx, 1)
.WriteInt32LEToBytes(ref state.idx, 0);
stream.Write(state.array);
// Collect all assembly names
foreach (var rec in records)
{
// Write used assembly names first
WriteAssemblyNames(state, rec);
// Write record structure
WriteSingleRecord(state, rec, false);
// Empty queue of reference objects
while (state.recordQueue.Count > 0)
{
WriteSingleRecord(state, state.recordQueue.Dequeue(), true);
}
}
// Write end
state.EnsureCapacity(1);
state.array.WriteByteToBytes(ref state.idx, (Byte)RecordTypeEnumeration.MessageEnd);
stream.Write(state.array);
}
private static void WriteAssemblyNames(SerializationState state, AbstractRecord curRecord)
{
if (curRecord != null)
{
switch (curRecord.Kind)
{
case RecordKind.Class:
var claas = (ClassRecord)curRecord;
WriteAssemblyName(state, claas);
foreach (var member in claas.Members)
{
WriteAssemblyName(state, member);
WriteAssemblyNames(state, member.Value as AbstractRecord);
}
break;
case RecordKind.Array:
var array = (ArrayRecord)curRecord;
WriteAssemblyName(state, array);
foreach (var elem in array.ValuesAsVector)
{
WriteAssemblyNames(state, elem as AbstractRecord);
}
break;
}
}
}
private void CheckpointRight(Stream stream)
{
try
{
switch (this.serializationState)
{
case SerializationState.Open:
this.serializationState = SerializationState.CheckpointRight;
Checkpoint(stream);
break;
case SerializationState.CheckpointLeft:
this.serializationState = SerializationState.Open;
break;
default:
throw new InvalidOperationException();
}
}
catch (Exception)
{
this.serializationState = SerializationState.Open;
throw;
}
}
internal void ReadFromSerializationState(SerializationState state)
{
ThrowIfInitialized();
_initialized = true;
InitializeComponent();
SetObjectState(state);
}
private void RestoreRight(Stream stream)
{
try
{
switch (this.serializationState)
{
case SerializationState.Open:
this.serializationState = SerializationState.RestoreRight;
Restore(stream);
break;
case SerializationState.RestoreLeft:
this.serializationState = SerializationState.Open;
break;
default:
throw new InvalidOperationException();
}
}
catch (Exception)
{
this.serializationState = SerializationState.Open;
throw;
}
}
/// <summary>
/// Gets a new <see cref="SerializationState"/> with default options.
/// </summary>
/// <returns>The <see cref="SerializationState"/>.</returns>
public SerializationState GetDefaultState()
{
if (defaultState == null)
{
lock (lockObj)
{
if (defaultState == null)
{
defaultState = ServiceHost.GetService<IConfigurationBuilder>().Configure();
}
}
}
SerializationState state;
lock (lockObj)
{
state = new SerializationState
{
CompressTypes = defaultState.CompressTypes,
Options = defaultState.Options,
};
}
return state;
}
public static void SaveStateData(string saveFileID)
{
string normalizedFileID = saveFileID.Substring(5);
FileInfo saveStateFilePath = CalculateFilePath(normalizedFileID);
Mod.Log.Log($"Saving to filePath:{saveStateFilePath.FullName}.");
if (saveStateFilePath.Exists)
{
// Make a backup
saveStateFilePath.CopyTo($"{saveStateFilePath.FullName}.bak", true);
}
try {
SerializationState state = new SerializationState {
staticState = State.EWState,
PlayerActorLocks = State.PlayerActorLocks,
LastPlayerActivatedActorGUID = State.LastPlayerActor,
ecmJammedActors = State.ECMJammedActors,
ecmProtectedActors = State.ECMProtectedActors,
narcedActors = State.NarcedActors,
taggedActors = State.TaggedActors
};
using (StreamWriter w = new StreamWriter(saveStateFilePath.FullName, false)) {
string json = JsonConvert.SerializeObject(state);
w.Write(json);
Mod.Log.Log($"Persisted state to file:{saveStateFilePath.FullName}.");
}
} catch (Exception e) {
Mod.Log.Log($"Failed to persist to disk at path {saveStateFilePath.FullName} due to error: {e.Message}");
}
}
public SerializationState GetObjectState()
{
var state = new SerializationState(this);
state.AddValue("class_name", ClassName);
return(state);
}
public void ReturnsTheObjectFromTheGetMethod()
{
var state = new SerializationState();
var foo = state.Get(() => new Foo(1));
Assert.That(foo.Bar, Is.EqualTo(1));
}
public void ReturnsTheObjectFromTheGetMethod()
{
var state = new SerializationState();
var foo = state.Get(() => new Foo(1));
Assert.That(foo.Bar, Is.EqualTo(1));
}
string IEncryptionMechanism.Decrypt(string cipherText, object encryptKey, SerializationState serializationState)
{
if (serializationState == null)
{
throw new ArgumentNullException(nameof(serializationState));
}
return(Decrypt(cipherText));
}
public string Decrypt(string cipherText, object encryptKey, SerializationState serializationState)
{
if (!cipherText.StartsWith(header))
{
return(cipherText);
}
return(cipherText.Substring(header.Length, cipherText.Length - header.Length - footer.Length)
.Replace("<", "<").Replace(">", ">"));
}
public void SetObjectState(SerializationState state)
{
Strength = state.GetValue("strength", Strength);
Dexterity = state.GetValue("dexterity", Dexterity);
Constitution = state.GetValue("constitution", Constitution);
Intelligence = state.GetValue("intelligence", Intelligence);
Wisdom = state.GetValue("wisdom", Wisdom);
Charisma = state.GetValue("charisma", Charisma);
}
public XSerializerXmlReader(XmlReader reader, IEncryptionMechanism encryptionMechanism, object encryptKey, SerializationState serializationState)
{
_primaryReader = reader;
_currentReader = reader;
_encryptionMechanism = encryptionMechanism;
_encryptKey = encryptKey;
_serializationState = serializationState;
}
/// <summary>
/// Uses the configuration builder to configure the default state.
/// </summary>
/// <param name="builder">The <see cref="IConfigurationBuilder"/>.</param>
public void SetDefaultState(Action<IConfigurationBuilder> builder)
{
var config = ServiceHost.GetService<IConfigurationBuilder>();
builder(config);
lock (lockObj)
{
defaultState = config.Configure();
}
}
/// <summary>
/// Returns the value of <paramref name="text"/>.
/// </summary>
/// <param name="text">Some text.</param>
/// <param name="encryptKey">Ignored.</param>
/// <param name="serializationState">Ignored.</param>
/// <returns>The value of <paramref name="text"/>.</returns>
public string Decrypt(string text, object encryptKey, SerializationState serializationState)
{
#if !BUILD
if (serializationState == null)
{
throw new ArgumentNullException(nameof(serializationState));
}
#endif
return(text);
}
public string Decrypt(string cipherText, object encryptKey, SerializationState serializationState)
{
LastSerializationState = serializationState;
var counts = serializationState.Get(() => new Counts());
counts.DecryptInvocationCount++;
return(Encoding.UTF8.GetString(Convert.FromBase64String(cipherText)));
}
public string Encrypt(string plainText, object encryptKey, SerializationState serializationState)
{
LastSerializationState = serializationState;
var counts = serializationState.Get(() => new Counts());
counts.EncryptInvocationCount++;
return(Convert.ToBase64String(Encoding.UTF8.GetBytes(plainText)));
}
internal override SerializationState Deserialize(SerializationState state)
{
var flags = DeserializeUnsignedShort(state);
state.Message.IsAQuery = IsSelectedBitFalse(flags, 0x8000);
state.Message.OperationCode = (OperationCode)((flags & 0x7800) >> 11);
state.Message.IsAuthoritative = IsSelectedBitTrue(flags, 0x0400);
return state;
}
public override void SetObjectState(SerializationState state)
{
Strength = state.GetValue("strength", 10);
Dexterity = state.GetValue("dexterity", 10);
Constitution = state.GetValue("constitution", 10);
Intelligence = state.GetValue("intelligence", 10);
Wisdom = state.GetValue("wisdom", 10);
Charisma = state.GetValue("charisma", 10);
Class = state.GetState("class")?.Instantiate <CharacterClass>();
}
/// <summary>
/// Reads the serialization state
/// </summary>
protected static SerializationState ReadState(BinaryReader reader)
{
SerializationState state = default(SerializationState);
state.AllowsCaching = reader.ReadBoolean();
state.PathRegex = SerializableRegex.Read(reader);
state.Name = reader.ReadString();
return(state);
}
public void SetObjectState(SerializationState state)
{
foreach (var componentName in state.Fields)
{
var componentSerializationState = state.GetState(componentName.Key);
var component = componentSerializationState.Instantiate <Component>(Hedgemen.RegisteredAssemblies, false);
InternalAddComponent(component);
component.ReadFromSerializationState(componentSerializationState);
}
}
public void ReturnsTheSameObjectFromEachCallToTheGetMethod()
{
var state = new SerializationState();
var foo1 = state.Get(() => new Foo(2));
var foo2 = state.Get(() => new Foo(2));
var foo3 = state.Get(() => new Foo(2));
Assert.That(foo1, Is.SameAs(foo2));
Assert.That(foo2, Is.SameAs(foo3));
}
public void ReturnsTheSameObjectFromEachCallToTheGetMethod()
{
var state = new SerializationState();
var foo1 = state.Get(() => new Foo(2));
var foo2 = state.Get(() => new Foo(2));
var foo3 = state.Get(() => new Foo(2));
Assert.That(foo1, Is.SameAs(foo2));
Assert.That(foo2, Is.SameAs(foo3));
}
protected ushort DeserializeUnsignedShort(SerializationState state)
{
ushort number;
if (_endianessChecker.IsLittleEndianSystem)
number = (ushort)((state.GetNextMessageByte() << 8) | state.GetNextMessageByte());
else
number = (ushort)(state.GetNextMessageByte() | (state.GetNextMessageByte() << 8));
return number;
}
/// <summary>
/// Encrypts the specified plain text.
/// </summary>
/// <param name="plainText">The plain text.</param>
/// <param name="encryptKey">
/// An object to used to look up invokation-specific encryption parameters.
/// </param>
/// <param name="serializationState">
/// An object that holds an arbitrary value that is passed to one or more encrypt
/// operations within a single serialization operation.
/// </param>
/// <returns></returns>
public string Encrypt(string plainText, object encryptKey, SerializationState serializationState)
{
var encryptor =
serializationState == null
? _crypto.GetEncryptor(encryptKey)
: serializationState.Get(() => _crypto.GetEncryptor(encryptKey));
var cipherText = encryptor.Encrypt(plainText);
return(cipherText);
}
/// <summary>
/// Decrypts the specified cipher text.
/// </summary>
/// <param name="cipherText">The cipher text.</param>
/// <param name="encryptKey">
/// An object to used to look up invokation-specific encryption parameters.
/// </param>
/// <param name="serializationState">
/// An object that holds an arbitrary value that is passed to one or more decrypt
/// operations within a single serialization operation.
/// </param>
/// <returns>The decrypted text.</returns>
public string Decrypt(string cipherText, object encryptKey, SerializationState serializationState)
{
var decryptor =
serializationState == null
? _crypto.GetDecryptor(encryptKey)
: serializationState.Get(() => _crypto.GetDecryptor(encryptKey));
var plainText = decryptor.Decrypt(cipherText);
return(plainText);
}
public SerializationState GetObjectState()
{
var state = new SerializationState(this);
foreach (var component in _components.Values)
{
state.AddValue(component.QueryComponentInfo().RegistryName, component.GetObjectState());
}
return(state);
}
public static void LoadStateData(string saveFileID)
{
ECMJammedActors.Clear();
ECMProtectedActors.Clear();
NarcedActors.Clear();
TaggedActors.Clear();
PlayerActorLocks.Clear();
EWState.Clear();
string normalizedFileID = saveFileID.Substring(5);
FileInfo stateFilePath = CalculateFilePath(normalizedFileID);
if (stateFilePath.Exists)
{
//LowVisibility.Logger.Log($"Reading saved state from file:{stateFilePath.FullName}.");
// Read the file
try {
SerializationState savedState = null;
using (StreamReader r = new StreamReader(stateFilePath.FullName)) {
string json = r.ReadToEnd();
//LowVisibility.Logger.Log($"State json is: {json}");
savedState = JsonConvert.DeserializeObject <SerializationState>(json);
}
// TODO: NEED TO REFRESH STATIC STATE ON ACTORS
State.EWState = savedState.staticState;
Mod.Log.Log($" -- StaticEWState.count: {savedState.staticState.Count}");
State.PlayerActorLocks = savedState.PlayerActorLocks;
Mod.Log.Log($" -- SourceActorLockStates.count: {savedState.PlayerActorLocks.Count}");
State.LastPlayerActor = savedState.LastPlayerActivatedActorGUID;
Mod.Log.Log($" -- LastPlayerActivatedActorGUID: {LastPlayerActor}");
State.ECMJammedActors = savedState.ecmJammedActors;
Mod.Log.Log($" -- ecmJammedActors.count: {savedState.ecmJammedActors.Count}");
State.ECMProtectedActors = savedState.ecmProtectedActors;
Mod.Log.Log($" -- ecmProtectedActors.count: {savedState.ecmProtectedActors.Count}");
State.NarcedActors = savedState.narcedActors;
Mod.Log.Log($" -- narcedActors.count: {savedState.narcedActors.Count}");
State.TaggedActors = savedState.taggedActors;
Mod.Log.Log($" -- taggedActors.count: {savedState.taggedActors.Count}");
Mod.Log.Log($"Loaded save state from file:{stateFilePath.FullName}.");
} catch (Exception e) {
Mod.Log.Log($"Failed to read saved state due to e: '{e.Message}'");
}
}
else
{
Mod.Log.Log($"FilePath:{stateFilePath} does not exist, not loading file.");
}
}
private static void WriteSingleRecord(SerializationState state, AbstractRecord record, Boolean forceWrite)
{
Int32 id;
if (state.TryAddRecord(record, out id) || forceWrite)
{
// If record hasn't been previously processed, or if we are told to write contents no matter what
switch (record.Kind)
{
case RecordKind.String:
var s = ((StringRecord)record).StringValue;
var len = UTF8.GetByteCount(s);
state.EnsureCapacity(10 + len);
state.array
.WriteByteToBytes(ref state.idx, (Byte)RecordTypeEnumeration.BinaryObjectString)
.WriteInt32LEToBytes(ref state.idx, id)
.WriteInt32Encoded7Bit(ref state.idx, len)
.WriteStringToBytes(ref state.idx, UTF8, s);
state.WriteArrayToStream();
break;
case RecordKind.Class:
WriteClassRecord(state, (ClassRecord)record, id);
break;
case RecordKind.Array:
WriteArrayRecord(state, (ArrayRecord)record, id);
break;
case RecordKind.PrimitiveWrapper:
// Write header
state.EnsureCapacity(2);
var p = ((PrimitiveWrapperRecord)record).Value;
var pType = GetPrimitiveType(p);
state.array
.WriteByteToBytes(ref state.idx, (Byte)RecordTypeEnumeration.MemberPrimitiveTyped)
.WriteByteToBytes(ref state.idx, (Byte)pType);
state.WriteArrayToStream();
// Write primitive
WritePrimitive(state, p, pType);
break;
}
}
else
{
// Record was already serialized, write member reference to it
state.EnsureCapacity(5);
state.array
.WriteByteToBytes(ref state.idx, (Byte)RecordTypeEnumeration.MemberReference)
.WriteInt32LEToBytes(ref state.idx, id);
state.WriteArrayToStream();
}
}
/// <summary>
/// <see cref="TypeSerializerWithSimpleTextSupport.Deserialize(string, SerializationState)"/>
/// </summary>
public override object Deserialize(string value, SerializationState state)
{
if (m_FormatSpecified)
{
try
{
// Try parsing using the specified format.
return DateTime.ParseExact(value, m_FormatAttribute.Format, System.Globalization.CultureInfo.CurrentCulture);
}
catch
{
}
}
// Try parsing with the system supplied strategy.
return DateTime.Parse(value);
}
/// <summary>
///
/// </summary>
/// <param name="obj"></param>
/// <param name="writer"></param>
/// <param name="state"></param>
public override void Serialize(object obj, XmlWriter writer, SerializationState state)
{
foreach (object item in (IList)obj)
{
ListItem listItem;
listItem = (ListItem)m_TypeToItemMap[item.GetType()];
writer.WriteStartElement(listItem.Alias);
if (listItem.Attribute != null
&& listItem.Attribute.SerializeAsValueNode
&& listItem.Attribute.ValueNodeAttributeName != null
&& listItem.Serializer is TypeSerializerWithSimpleTextSupport)
{
writer.WriteAttributeString(listItem.Attribute.ValueNodeAttributeName,
((TypeSerializerWithSimpleTextSupport)listItem.Serializer).Serialize(item, state));
}
else
{
listItem.Serializer.Serialize(item, writer, state);
}
writer.WriteEndElement();
}
}
/// <summary>
///
/// </summary>
/// <param name="obj"></param>
/// <param name="writer"></param>
/// <param name="state"></param>
public override void Serialize(object obj, XmlWriter writer, SerializationState state)
{
TypeSerializerWithSimpleTextSupport simpleSerializer;
state.SerializationStart(obj);
try
{
// Serialize attributes...
foreach (SerializationMemberInfo smi in m_AttributeMembersMap.Values)
{
object val;
val = smi.GetValue(obj);
if (smi.TreatAsNullIfEmpty)
{
if (smi.LogicalType.IsValueType)
{
if (Activator.CreateInstance(smi.LogicalType).Equals(obj))
{
val = null;
}
}
}
if (state.ShouldSerialize(val))
{
simpleSerializer = (TypeSerializerWithSimpleTextSupport)smi.Serializer;
writer.WriteStartAttribute(smi.SerializedName, "");
writer.WriteString(simpleSerializer.Serialize(val, state));
writer.WriteEndAttribute();
}
}
// Serialize elements...
foreach (SerializationMemberInfo smi in m_ElementMembersMap.Values)
{
object val;
val = smi.GetValue(obj);
if (smi.TreatAsNullIfEmpty)
{
if (smi.LogicalType.IsValueType)
{
if (Activator.CreateInstance(smi.LogicalType).Equals(val))
{
val = null;
}
}
}
simpleSerializer = smi.Serializer as TypeSerializerWithSimpleTextSupport;
if (state.ShouldSerialize(val))
{
if (smi.Namespace.Length > 0)
{
writer.WriteStartElement(state.Parameters.Namespaces.GetPrefix(smi.Namespace), smi.SerializedName, smi.Namespace);
}
else
{
writer.WriteStartElement(smi.SerializedName, "");
}
if (smi.SerializeAsValueNodeAttributeName != null)
{
writer.WriteAttributeString(smi.SerializeAsValueNodeAttributeName, val.ToString());
}
else if (smi.SerializeAsCData)
{
writer.WriteCData(simpleSerializer.Serialize(val, state));
}
else
{
smi.Serializer.Serialize(val, writer, state);
}
writer.WriteEndElement();
}
}
}
finally
{
state.SerializationEnd(obj);
}
}
/// <summary>
///
/// </summary>
/// <param name="reader"></param>
/// <param name="state"></param>
/// <returns></returns>
public override object Deserialize(XmlReader reader, SerializationState state)
{
object retval;
SerializationMemberInfo serializationMember;
ISerializationUnhandledMarkupListener uhm;
retval = Activator.CreateInstance(m_Type);
state.DeserializationStart(retval);
uhm = retval as ISerializationUnhandledMarkupListener;
if (reader.AttributeCount > 0)
{
for (int i = 0; i < reader.AttributeCount; i++)
{
reader.MoveToAttribute(i);
if (reader.Prefix == "xmlns")
{
continue;
}
if (reader.Prefix.Length > 0)
{
serializationMember = (SerializationMemberInfo)m_AttributeMembersMap[state.Parameters.Namespaces.GetNamespace(reader.Prefix) + (char)0xff + reader.LocalName];
}
else
{
serializationMember = (SerializationMemberInfo)m_AttributeMembersMap[reader.Name];
}
if (serializationMember == null)
{
// Unknown attribute.
if (uhm != null)
{
uhm.UnhandledAttribute(reader.Name, reader.Value);
}
}
else
{
serializationMember.SetValue(retval, serializationMember.Serializer.Deserialize(reader, state));
}
}
reader.MoveToElement();
}
if (reader.IsEmptyElement)
{
reader.ReadStartElement();
return retval;
}
reader.ReadStartElement();
// Read elements
while (true)
{
XmlReaderHelper.ReadUntilAnyTypesReached(reader,
new XmlNodeType[] { XmlNodeType.Element, XmlNodeType.EndElement});
if (reader.NodeType == XmlNodeType.Element)
{
if (reader.Prefix.Length > 0)
{
serializationMember = (SerializationMemberInfo)m_ElementMembersMap[state.Parameters.Namespaces.GetNamespace(reader.Prefix) + (char)0xff + reader.LocalName];
}
else
{
serializationMember = (SerializationMemberInfo)m_ElementMembersMap[reader.LocalName];
}
if (serializationMember == null)
{
// Unknown element.
reader.Read();
XmlReaderHelper.ReadAndApproachMatchingEndElement(reader);
}
else
{
if (serializationMember.SerializeAsValueNodeAttributeName != null
&& serializationMember.Serializer is TypeSerializerWithSimpleTextSupport)
{
string s;
s = reader.GetAttribute(serializationMember.SerializeAsValueNodeAttributeName);
serializationMember.SetValue(retval, ((TypeSerializerWithSimpleTextSupport)(serializationMember.Serializer)).Deserialize(s, state));
XmlReaderHelper.ReadAndConsumeMatchingEndElement(reader);
}
else
{
serializationMember.SetValue(retval, serializationMember.Serializer.Deserialize(reader, state));
}
}
}
else
{
if (reader.NodeType == XmlNodeType.EndElement)
{
reader.ReadEndElement();
}
else
{
if (uhm != null)
{
uhm.UnhandledOther(reader.ReadOuterXml());
}
}
break;
}
}
state.DeserializationEnd(retval);
return retval;
}
public EncryptingTextWriter(TextWriter writer, IEncryptionMechanism encryptionMechanism, object encryptKey, SerializationState serializationState)
{
_writer = writer;
_encryptionMechanism = encryptionMechanism;
_encryptKey = encryptKey;
_serializationState = serializationState;
}
public override object Deserialize(string value, SerializationState state)
{
return Enum.Parse(m_Type, value, true);
}
/// <summary>
/// Decrypts the specified cipher text using the <see cref="IEncryptionMechanism"/>
/// specified by the <see cref="Current"/> property.
/// </summary>
/// <param name="cipherText">The cipher text.</param>
/// <param name="encryptKey">
/// An object to used to look up invokation-specific encryption parameters.
/// </param>
/// <param name="serializationState">
/// An object that holds an arbitrary value that is passed to one or more
/// decrypt operations within a single serialization operation.
/// </param>
/// <returns>The decrypted text.</returns>
public static string Decrypt(string cipherText, object encryptKey, SerializationState serializationState)
{
return Current.Decrypt(cipherText, encryptKey, serializationState);
}
public void HasAnInitialValueOfNull()
{
var state = new SerializationState();
Assert.That(state.GetRawValue(), Is.Null);
}
/// <summary>
///
/// </summary>
/// <param name="reader"></param>
/// <param name="state"></param>
/// <returns></returns>
public override object Deserialize(XmlReader reader, SerializationState state)
{
object retval;
LightSerializationMember serializationMember;
ISerializationUnhandledMarkupListener uhm;
retval = Activator.CreateInstance(m_Type);
state.DeserializationStart(retval);
uhm = retval as ISerializationUnhandledMarkupListener;
if (reader.AttributeCount > 0)
{
for (int i = 0; i < reader.AttributeCount; i++)
{
reader.MoveToAttribute(i);
serializationMember = (LightSerializationMember)m_AttributeMembersMap[reader.Name];
if (serializationMember == null)
{
// Unknown attribute.
if (uhm != null)
{
uhm.UnhandledAttribute(reader.Name, reader.Value);
}
}
else
{
serializationMember.SetValue(retval, serializationMember.Serializer.Deserialize(reader, state));
}
}
reader.MoveToElement();
}
if (reader.IsEmptyElement)
{
reader.ReadStartElement();
return retval;
}
reader.ReadStartElement();
// Read elements
while (true)
{
XmlReaderHelper.ReadUntilAnyTypesReached(reader,
new XmlNodeType[] { XmlNodeType.Element, XmlNodeType.EndElement});
if (reader.NodeType == XmlNodeType.Element)
{
serializationMember = (LightSerializationMember)m_ElementMembersMap[reader.Name];
if (serializationMember == null)
{
// Unknown element.
}
else
{
serializationMember.SetValue(retval, serializationMember.Serializer.Deserialize(reader, state));
}
}
else
{
if (reader.NodeType == XmlNodeType.EndElement)
{
reader.ReadEndElement();
}
else
{
if (uhm != null)
{
uhm.UnhandledOther(reader.ReadOuterXml());
}
}
break;
}
}
state.DeserializationEnd(retval);
return retval;
}
public string Decrypt(string cipherText, object encryptKey, SerializationState serializationState)
{
LastSerializationState = serializationState;
var counts = serializationState.Get(() => new Counts());
counts.DecryptInvocationCount++;
return Encoding.UTF8.GetString(Convert.FromBase64String(cipherText));
}
string IEncryptionMechanism.Decrypt(string cipherText, object encryptKey, SerializationState serializationState)
{
return Decrypt(cipherText);
}
public void ThrowsAnExceptionIfGetValueReturnsNull()
{
var state = new SerializationState();
Assert.That(() => state.Get<Foo>(() => null), Throws.ArgumentException);
}
/// <summary>
///
/// </summary>
/// <param name="reader"></param>
/// <param name="state"></param>
/// <returns></returns>
public override object Deserialize(XmlReader reader, SerializationState state)
{
IList retval = null;
if (m_ListType.IsArray)
{
retval = new ArrayList();
}
else
{
retval = (IList)Activator.CreateInstance(m_ListType);
state.DeserializationStart(retval);
}
// Go thru all elements and deserialize each one.
if (reader.IsEmptyElement)
{
reader.ReadStartElement();
}
else
{
reader.ReadStartElement();
for (;;)
{
ListItem listItem;
XmlReaderHelper.ReadUntilAnyTypesReached(reader, XmlReaderHelper.ElementOrEndElement);
if (reader.NodeType == XmlNodeType.Element)
{
listItem = (ListItem)m_AliasToItemMap[reader.Name];
if (listItem.Attribute != null
&& listItem.Attribute.SerializeAsValueNode
&& listItem.Attribute.ValueNodeAttributeName != null
&& listItem.Serializer is TypeSerializerWithSimpleTextSupport)
{
string s;
s = reader.GetAttribute(listItem.Attribute.ValueNodeAttributeName);
retval.Add(((TypeSerializerWithSimpleTextSupport)listItem.Serializer).Deserialize(s, state));
XmlReaderHelper.ReadAndConsumeMatchingEndElement(reader);
}
else
{
retval.Add(listItem.Serializer.Deserialize(reader, state));
}
}
else
{
if (reader.NodeType == XmlNodeType.EndElement)
{
reader.ReadEndElement();
}
break;
}
}
}
if (m_ListType.IsArray)
{
Array array = Array.CreateInstance(m_ListType.GetElementType(), retval.Count);
state.DeserializationStart(retval);
retval.CopyTo(array, 0);
retval = array;
}
state.DeserializationEnd(retval);
return retval;
}
internal override SerializationState Deserialize(SerializationState state)
{
state.Message.Id = DeserializeUnsignedShort(state);
return state;
}
public override string Serialize(object obj, SerializationState state)
{
return Enum.GetName(m_Type, obj);
}
private XSerializerXmlReader(string xml, IEncryptionMechanism encryptionMechanism, object encryptKey, SerializationState serializationState)
: this(new XmlTextReader(new StringReader(xml)), encryptionMechanism, encryptKey, serializationState)
{
}
/// <summary>
/// <see cref="TypeSerializer.Deserialize(XmlReader, SerializationState)"/>
/// </summary>
public override object Deserialize(XmlReader reader, SerializationState state)
{
return null;
}
string IEncryptionMechanism.Encrypt(string plainText, object encryptKey, SerializationState serializationState)
{
return Encrypt(plainText);
}
/// <summary>
/// <see cref="TypeSerializer.Serialize(object, XmlWriter, SerializationState)"/>
/// </summary>
public override void Serialize(object obj, XmlWriter writer, SerializationState state)
{
}
internal abstract SerializationState Deserialize(SerializationState state);
/// <summary>
/// <see cref="TypeSerializerWithSimpleTextSupport.Serialize(object, SerializationState)"/>
/// </summary>
public override string Serialize(object obj, SerializationState state)
{
return ((DateTime)obj).ToString(m_FormatAttribute.Format);
}
public string Encrypt(string plainText, object encryptKey, SerializationState serializationState)
{
LastSerializationState = serializationState;
var counts = serializationState.Get(() => new Counts());
counts.EncryptInvocationCount++;
return Convert.ToBase64String(Encoding.UTF8.GetBytes(plainText));
}
/// <summary>
/// Returns the value of <paramref name="text"/>.
/// </summary>
/// <param name="text">Some text.</param>
/// <param name="encryptKey">Ignored.</param>
/// <param name="serializationState">Ignored.</param>
/// <returns>The value of <paramref name="text"/>.</returns>
public string Decrypt(string text, object encryptKey, SerializationState serializationState)
{
return text;
}
/// <summary>
/// Encrypts the specified plain text using the <see cref="IEncryptionMechanism"/>
/// specified by the <see cref="Current"/> property.
/// </summary>
/// <param name="plainText">The plain text.</param>
/// <param name="encryptKey">
/// An object to used to look up invokation-specific encryption parameters.
/// </param>
/// <param name="serializationState">
/// An object that holds an arbitrary value that is passed to one or more
/// encrypt operations within a single serialization operation.
/// </param>
/// <returns>The encrypted text.</returns>
public static string Encrypt(string plainText, object encryptKey, SerializationState serializationState)
{
return Current.Encrypt(plainText, encryptKey, serializationState);
}
public void ThrowsAnExceptionIfGetValueIsNull()
{
var state = new SerializationState();
Assert.That(() => state.Get<Foo>(null), Throws.InstanceOf<ArgumentNullException>());
}
