From 41e9c804563fe781a630f8c60457fe15895c8cb6 Mon Sep 17 00:00:00 2001 From: AlexVallat Date: Fri, 21 Jun 2013 18:28:49 +0100 Subject: [PATCH] Strictly for experimentation. When saving a databse, it will be saved in protocol buffer format. Opening will work for either xml or protocol buffers. --- .../KeePassLib2Android.csproj | 4 + .../Serialization/KdbxFile.Read.cs | 41 +- .../Serialization/KdbxFile.Write.cs | 5 + .../Serialization/ProtoBuf/KdbpFile.cs | 1425 +++++++++ src/ProtoBuf/protobuf-net.dll | Bin 0 -> 187392 bytes src/ProtoBuf/protobuf-net.pdb | Bin 0 -> 615936 bytes src/ProtoBuf/protobuf-net.xml | 2747 +++++++++++++++++ 7 files changed, 4220 insertions(+), 2 deletions(-) create mode 100644 src/KeePassLib2Android/Serialization/ProtoBuf/KdbpFile.cs create mode 100644 src/ProtoBuf/protobuf-net.dll create mode 100644 src/ProtoBuf/protobuf-net.pdb create mode 100644 src/ProtoBuf/protobuf-net.xml diff --git a/src/KeePassLib2Android/KeePassLib2Android.csproj b/src/KeePassLib2Android/KeePassLib2Android.csproj index d925d883..712720e4 100644 --- a/src/KeePassLib2Android/KeePassLib2Android.csproj +++ b/src/KeePassLib2Android/KeePassLib2Android.csproj @@ -47,6 +47,9 @@ SdkOnly + + ..\ProtoBuf\protobuf-net.dll + @@ -126,6 +129,7 @@ + diff --git a/src/KeePassLib2Android/Serialization/KdbxFile.Read.cs b/src/KeePassLib2Android/Serialization/KdbxFile.Read.cs index 03456962..4eff0c4a 100644 --- a/src/KeePassLib2Android/Serialization/KdbxFile.Read.cs +++ b/src/KeePassLib2Android/Serialization/KdbxFile.Read.cs @@ -127,8 +127,34 @@ namespace KeePassLib.Serialization } else m_randomStream = null; // No random stream for plain-text files - ReadXmlStreamed(readerStream, hashedStream); - // ReadXmlDom(readerStream); + // Test: read to memory + var stopWatch = Stopwatch.StartNew(); + var memStream = new MemoryStream((int)hashedStream.Length); + CopyStream(readerStream, memStream); + readerStream.Close(); + readerStream = memStream; + System.Diagnostics.Debug.WriteLine(String.Format("Copy input stream: {0}ms", stopWatch.ElapsedMilliseconds)); + + var isXml = memStream.ReadByte() == '<'; + memStream.Seek(0, SeekOrigin.Begin); + + if (isXml) + { + stopWatch.Restart(); + + ReadXmlStreamed(readerStream, hashedStream); + System.Diagnostics.Debug.WriteLine(String.Format("ReadXmlStreamed: {0}ms", stopWatch.ElapsedMilliseconds)); + + } + else + { + stopWatch.Restart(); + + KdbpFile.ReadDocument(m_pwDatabase, readerStream, m_pbProtectedStreamKey, m_pbHashOfHeader); + + System.Diagnostics.Debug.WriteLine(String.Format("KdbpFile.ReadDocument: {0}ms", stopWatch.ElapsedMilliseconds)); + + } readerStream.Close(); // GC.KeepAlive(br); @@ -141,6 +167,17 @@ namespace KeePassLib.Serialization finally { CommonCleanUpRead(sSource, hashedStream); } } + public static void CopyStream(Stream input, Stream output) + { + byte[] buffer = new byte[4096]; + int read; + while ((read = input.Read(buffer, 0, buffer.Length)) > 0) + { + output.Write(buffer, 0, read); + } + output.Seek(0, SeekOrigin.Begin); + } + private void CommonCleanUpRead(Stream sSource, HashingStreamEx hashedStream) { hashedStream.Close(); diff --git a/src/KeePassLib2Android/Serialization/KdbxFile.Write.cs b/src/KeePassLib2Android/Serialization/KdbxFile.Write.cs index 802feaf0..fbc31e6c 100644 --- a/src/KeePassLib2Android/Serialization/KdbxFile.Write.cs +++ b/src/KeePassLib2Android/Serialization/KdbxFile.Write.cs @@ -122,11 +122,16 @@ namespace KeePassLib.Serialization writerStream = hashedStream; else { Debug.Assert(false); throw new FormatException("KdbFormat"); } + /* m_xmlWriter = new XmlTextWriter(writerStream, encNoBom); WriteDocument(pgDataSource); m_xmlWriter.Flush(); m_xmlWriter.Close(); + */ + + KdbpFile.WriteDocument(m_pwDatabase, writerStream, m_pbProtectedStreamKey, m_pbHashOfHeader); + writerStream.Close(); } finally { CommonCleanUpWrite(sSaveTo, hashedStream); } diff --git a/src/KeePassLib2Android/Serialization/ProtoBuf/KdbpFile.cs b/src/KeePassLib2Android/Serialization/ProtoBuf/KdbpFile.cs new file mode 100644 index 00000000..326d391b --- /dev/null +++ b/src/KeePassLib2Android/Serialization/ProtoBuf/KdbpFile.cs @@ -0,0 +1,1425 @@ +using System; +using System.Collections.Generic; +using System.Text; +using ProtoBuf; +using System.Drawing; +using KeePassLib.Collections; +using KeePassLib.Security; +using KeePassLib.Cryptography; +using System.IO; +using ProtoBuf.Meta; + +namespace KeePassLib.Serialization +{ + internal class KdbpFile + { + public static void WriteDocument(PwDatabase database, Stream stream, byte[] protectedStreamKey, byte[] hashOfHeader) + { + var context = new SerializationContext + { + Context = new BufferContext(database, + new CryptoRandomStream(CrsAlgorithm.Salsa20, protectedStreamKey), hashOfHeader) + }; + + RuntimeTypeModel.Default.Serialize(stream, new PwDatabaseBuffer(database), context); + } + + public static void ReadDocument(PwDatabase database, Stream stream, byte[] protectedStreamKey, byte[] expectedHashOfHeader) + { + + var context = new BufferContext(database, new CryptoRandomStream(CrsAlgorithm.Salsa20, protectedStreamKey)); + + // Deserialisation will occur into the database already in context. + RuntimeTypeModel.Default.Deserialize(stream, null, typeof(PwDatabaseBuffer), new SerializationContext { Context = context }); + + if (expectedHashOfHeader.Length > 0 && + !KeePassLib.Utility.MemUtil.ArraysEqual(context.HeaderHash, expectedHashOfHeader)) + { + throw new IOException(KeePassLib.Resources.KLRes.FileCorrupted); + } + } + + private class BufferContext + { + // ProtectedBinary objects may be referred to multipe times by entry histories, so reference them only once by ensuring a 1:1 mapping to the buffer wrapping them. + public readonly Dictionary BinaryPool = new Dictionary(); + + public readonly PwDatabase Database; + public readonly CryptoRandomStream RandomStream; + public byte[] HeaderHash; + + public BufferContext(PwDatabase database, CryptoRandomStream randomStream, byte[] pbHashOfHeader = null) + { + Database = database; + RandomStream = randomStream; + HeaderHash = pbHashOfHeader; + } + } + + [ProtoContract] + private class PwDatabaseBuffer + { + #region Serialization + + private PwDatabase mDatabase; + private PwDeletedObjectListBuffer mDeletedObjects; + private PwCustomIconListBuffer mCustomIcons; + + public PwDatabaseBuffer(PwDatabase database) + { + mDatabase = database; + mDeletedObjects = new PwDeletedObjectListBuffer(mDatabase.DeletedObjects); + mCustomIcons = new PwCustomIconListBuffer(mDatabase.CustomIcons); + } + + [ProtoBeforeSerialization] + private void BeforeSerialization(SerializationContext context) + { + var bufferContext = (BufferContext)context.Context; + + System.Diagnostics.Debug.Assert(mDatabase == bufferContext.Database); + + HeaderHash = bufferContext.HeaderHash; + } + #endregion + + #region Deserialization + private PwDatabaseBuffer() + { + } + + [ProtoBeforeDeserialization] + private void BeforeDeserialization(SerializationContext context) + { + var bufferContext = (BufferContext)context.Context; + + mDatabase = bufferContext.Database; + mDeletedObjects = new PwDeletedObjectListBuffer(mDatabase.DeletedObjects); + mCustomIcons = new PwCustomIconListBuffer(mDatabase.CustomIcons); + } + + [ProtoAfterDeserialization] + private void AfterDeserialization(SerializationContext context) + { + var bufferContext = (BufferContext)context.Context; + + bufferContext.HeaderHash = HeaderHash; + } + #endregion + + [ProtoMember(1)] + public string Generator + { + get { return PwDatabase.LocalizedAppName; } + set { /* Ignore */ } + } + + [ProtoMember(2, OverwriteList = true)] + public byte[] HeaderHash; + + [ProtoMember(3)] + public string Name + { + get { return mDatabase.Name; } + set { mDatabase.Name = value; } + } + + [ProtoMember(4)] + public DateTime NameChanged + { + get { return mDatabase.NameChanged; } + set { mDatabase.NameChanged = value; } + } + + [ProtoMember(5)] + public string Description + { + get { return mDatabase.Description; } + set { mDatabase.Description = value; } + } + + [ProtoMember(6)] + public DateTime DescriptionChanged + { + get { return mDatabase.DescriptionChanged; } + set { mDatabase.DescriptionChanged = value; } + } + + [ProtoMember(7)] + public string DefaultUserName + { + get { return mDatabase.DefaultUserName; } + set { mDatabase.DefaultUserName = value; } + } + + [ProtoMember(8)] + public DateTime DefaultUserNameChanged + { + get { return mDatabase.DefaultUserNameChanged; } + set { mDatabase.DefaultUserNameChanged = value; } + } + + [ProtoMember(9)] + public uint MaintenanceHistoryDays + { + get { return mDatabase.MaintenanceHistoryDays; } + set { mDatabase.MaintenanceHistoryDays = value; } + } + + [ProtoMember(10)] + public int Color + { + get { return mDatabase.Color.ToArgb(); } + set { mDatabase.Color = System.Drawing.Color.FromArgb(value); } + } + + [ProtoMember(11)] + public DateTime MasterKeyChanged + { + get { return mDatabase.MasterKeyChanged; } + set { mDatabase.MasterKeyChanged = value; } + } + + [ProtoMember(12)] + public long MasterKeyChangeRec + { + get { return mDatabase.MasterKeyChangeRec; } + set { mDatabase.MasterKeyChangeRec = value; } + } + + [ProtoMember(13)] + public long MasterKeyChangeForce + { + get { return mDatabase.MasterKeyChangeForce; } + set { mDatabase.MasterKeyChangeForce = value; } + } + + [ProtoMember(14)] + public MemoryProtectionConfigBuffer MemoryProtection + { + get { return new MemoryProtectionConfigBuffer(mDatabase.MemoryProtection); } + set { mDatabase.MemoryProtection = value.MemoryProtectionConfig; } + } + + [ProtoMember(15)] + public PwCustomIconListBuffer CustomIcons + { + get { return mCustomIcons; } + } + + [ProtoMember(16)] + public bool RecycleBinEnabled + { + get { return mDatabase.RecycleBinEnabled; } + set { mDatabase.RecycleBinEnabled = value; } + } + + [ProtoMember(17, OverwriteList = true)] + public byte[] RecycleBinUuid + { + get { return mDatabase.RecycleBinUuid.UuidBytes; } + set { mDatabase.RecycleBinUuid = new PwUuid(value); } + } + + [ProtoMember(18)] + public DateTime RecycleBinChanged + { + get { return mDatabase.RecycleBinChanged; } + set { mDatabase.RecycleBinChanged = value; } + } + + [ProtoMember(19, OverwriteList = true)] + public byte[] EntryTemplatesGroup + { + get { return mDatabase.EntryTemplatesGroup.UuidBytes; } + set { mDatabase.EntryTemplatesGroup = new PwUuid(value); } + } + + [ProtoMember(20)] + public DateTime EntryTemplatesGroupChanged + { + get { return mDatabase.EntryTemplatesGroupChanged; } + set { mDatabase.EntryTemplatesGroupChanged = value; } + } + + [ProtoMember(21)] + public int HistoryMaxItems + { + get { return mDatabase.HistoryMaxItems; } + set { mDatabase.HistoryMaxItems = value; } + } + + [ProtoMember(22)] + public long HistoryMaxSize + { + get { return mDatabase.HistoryMaxSize; } + set { mDatabase.HistoryMaxSize = value; } + } + + [ProtoMember(23, OverwriteList = true)] + public byte[] LastSelectedGroup + { + get { return mDatabase.LastSelectedGroup.UuidBytes; } + set { mDatabase.LastSelectedGroup = new PwUuid(value); } + } + + [ProtoMember(24, OverwriteList = true)] + public byte[] LastTopVisibleGroup + { + get { return mDatabase.LastTopVisibleGroup.UuidBytes; } + set { mDatabase.LastTopVisibleGroup = new PwUuid(value); } + } + + [ProtoMember(25)] + public StringDictionaryExBuffer CustomData + { + get { return new StringDictionaryExBuffer(mDatabase.CustomData); } + set { mDatabase.CustomData = value.StringDictionaryEx; } + } + + [ProtoMember(27)] + public PwGroupBuffer RootGroup + { + get { return new PwGroupBuffer(mDatabase.RootGroup); } + set { mDatabase.RootGroup = value.Group; } + } + + [ProtoMember(28)] + public PwDeletedObjectListBuffer DeletedObjects + { + get { return mDeletedObjects; } + } + } + + [ProtoContract] + private class StringDictionaryExBuffer : IEnumerable> + { + #region Serialization + private StringDictionaryEx mStringDictionaryEx; + + public StringDictionaryExBuffer(StringDictionaryEx stringDictionaryEx) + { + mStringDictionaryEx = stringDictionaryEx; + } + #endregion + + #region Deserialization + private StringDictionaryExBuffer() + { + mStringDictionaryEx = new StringDictionaryEx(); + } + + public StringDictionaryEx StringDictionaryEx { get { return mStringDictionaryEx; } } + + public void Add(KeyValuePair kvp) + { + mStringDictionaryEx.Set(kvp.Key, kvp.Value); + } + #endregion + + public IEnumerator> GetEnumerator() + { + return mStringDictionaryEx.GetEnumerator(); + } + + System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() + { + return GetEnumerator(); + } + } + + [ProtoContract] + private class PwCustomIconListBuffer : IEnumerable + { + private List mCustomIcons; + #region Serialization + public PwCustomIconListBuffer(List customIcons) + { + mCustomIcons = customIcons; + } + #endregion + + #region Deserialization + public void Add(PwCustomIconBuffer item) + { + mCustomIcons.Add(item.CustomIcon); + } + #endregion + + public IEnumerator GetEnumerator() + { + foreach (var customIcon in mCustomIcons) + { + yield return new PwCustomIconBuffer(customIcon); + } + } + + System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() + { + return GetEnumerator(); + } + } + + [ProtoContract] + private class PwCustomIconBuffer + { + #region Serialization + private PwCustomIcon mCustomIcon; + public PwCustomIconBuffer(PwCustomIcon CustomIcon) + { + mCustomIcon = CustomIcon; + Uuid = mCustomIcon.Uuid.UuidBytes; + ImageData = mCustomIcon.ImageDataPng; + } + #endregion + + #region Deserialization + private PwCustomIconBuffer() + { + } + + [ProtoAfterDeserialization] + private void AfterDeserialization(SerializationContext context) + { + mCustomIcon = new PwCustomIcon(new PwUuid(Uuid), ImageData); + } + + public PwCustomIcon CustomIcon { get { return mCustomIcon; } } + #endregion + + [ProtoMember(1, OverwriteList = true)] + public byte[] Uuid; + + [ProtoMember(2, OverwriteList = true)] + public byte[] ImageData; + } + + [ProtoContract] + private class MemoryProtectionConfigBuffer + { + #region Serialization + private readonly MemoryProtectionConfig mMemoryProtectionConfig; + + public MemoryProtectionConfigBuffer(MemoryProtectionConfig memoryProtectionConfig) + { + mMemoryProtectionConfig = memoryProtectionConfig; + } + #endregion + + #region Deserialization + private MemoryProtectionConfigBuffer() + { + mMemoryProtectionConfig = new MemoryProtectionConfig(); + } + + public MemoryProtectionConfig MemoryProtectionConfig { get { return mMemoryProtectionConfig; } } + #endregion + + [ProtoMember(1)] + public bool ProtectTitle + { + get { return mMemoryProtectionConfig.ProtectTitle; } + set { mMemoryProtectionConfig.ProtectTitle = value; } + } + + [ProtoMember(2)] + public bool ProtectUserName + { + get { return mMemoryProtectionConfig.ProtectUserName; } + set { mMemoryProtectionConfig.ProtectUserName = value; } + } + + [ProtoMember(3)] + public bool ProtectPassword + { + get { return mMemoryProtectionConfig.ProtectPassword; } + set { mMemoryProtectionConfig.ProtectPassword = value; } + } + + [ProtoMember(4)] + public bool ProtectUrl + { + get { return mMemoryProtectionConfig.ProtectUrl; } + set { mMemoryProtectionConfig.ProtectUrl = value; } + } + + [ProtoMember(5)] + public bool ProtectNotes + { + get { return mMemoryProtectionConfig.ProtectNotes; } + set { mMemoryProtectionConfig.ProtectNotes = value; } + } + } + + [ProtoContract] + private class PwDeletedObjectListBuffer : PwObjectListBufferBase + { + #region Serialization + public PwDeletedObjectListBuffer(PwObjectList objectList) + : base(objectList) + { + } + + protected override PwDeletedObjectBuffer CreateBuffer(PwDeletedObject item) + { + return new PwDeletedObjectBuffer(item); + } + #endregion + + #region Deserialization + private PwDeletedObjectListBuffer() + : base() + { + } + + public override void Add(PwDeletedObjectBuffer item) + { + ObjectList.Add(item.DeletedObject); + } + #endregion + } + + [ProtoContract] + private class PwDeletedObjectBuffer + { + #region Serialization + private readonly PwDeletedObject mDeletedObject; + + public PwDeletedObjectBuffer(PwDeletedObject deletedObject) + { + mDeletedObject = deletedObject; + } + #endregion + + #region Deserialization + private PwDeletedObjectBuffer() + { + mDeletedObject = new PwDeletedObject(); + } + + public PwDeletedObject DeletedObject { get { return mDeletedObject; } } + #endregion + + [ProtoMember(1, OverwriteList = true)] + public byte[] Uuid + { + get { return mDeletedObject.Uuid.UuidBytes; } + set { mDeletedObject.Uuid = new PwUuid(value); } + } + + [ProtoMember(2)] + public DateTime DeletionTime + { + get { return mDeletedObject.DeletionTime; } + set { mDeletedObject.DeletionTime = value; } + } + } + + [ProtoContract] + private class PwGroupBuffer + { + #region Serialization + private readonly PwGroup mGroup; + private readonly PwGroupEntryListBuffer mEntries; + private readonly PwGroupGroupListBuffer mGroups; + + public PwGroupBuffer(PwGroup group) + { + mGroup = group; + mEntries = new PwGroupEntryListBuffer(mGroup); + mGroups = new PwGroupGroupListBuffer(mGroup); + } + #endregion + + #region Deserialization + private PwGroupBuffer() + { + mGroup = new PwGroup(false, false); + mEntries = new PwGroupEntryListBuffer(mGroup); + mGroups = new PwGroupGroupListBuffer(mGroup); + } + + public PwGroup Group { get { return mGroup; } } + #endregion + + [ProtoMember(1, OverwriteList = true)] + public byte[] Uuid + { + get { return mGroup.Uuid.UuidBytes; } + set { mGroup.Uuid = new PwUuid(value); } + } + + [ProtoMember(2)] + public string Name + { + get { return mGroup.Name; } + set { mGroup.Name = value; } + } + + [ProtoMember(3)] + public string Notes + { + get { return mGroup.Notes; } + set { mGroup.Notes = value; } + } + + [ProtoMember(4)] + public PwIcon IconId + { + get { return mGroup.IconId; } + set { mGroup.IconId = value; } + } + + [ProtoMember(5, OverwriteList = true)] + public byte[] CustomIconUuid + { + get { return mGroup.CustomIconUuid.UuidBytes; } + set { mGroup.CustomIconUuid = new PwUuid(value); } + } + + [ProtoMember(6)] + public bool IsExpanded + { + get { return mGroup.IsExpanded; } + set { mGroup.IsExpanded = value; } + } + + [ProtoMember(7)] + public string DefaultAutoTypeSequence + { + get { return mGroup.DefaultAutoTypeSequence; } + set { mGroup.DefaultAutoTypeSequence = value; } + } + + [ProtoMember(8)] + public DateTime LastModificationTime + { + get { return mGroup.LastModificationTime; } + set { mGroup.LastModificationTime = value; } + } + + [ProtoMember(9)] + public DateTime CreationTime + { + get { return mGroup.CreationTime; } + set { mGroup.CreationTime = value; } + } + + [ProtoMember(10)] + public DateTime LastAccessTime + { + get { return mGroup.LastAccessTime; } + set { mGroup.LastAccessTime = value; } + } + + [ProtoMember(11)] + public DateTime ExpiryTime + { + get { return mGroup.ExpiryTime; } + set { mGroup.ExpiryTime = value; } + } + + [ProtoMember(12)] + public bool Expires + { + get { return mGroup.Expires; } + set { mGroup.Expires = value; } + } + + [ProtoMember(13)] + public ulong UsageCount + { + get { return mGroup.UsageCount; } + set { mGroup.UsageCount = value; } + } + + [ProtoMember(14)] + public DateTime LocationChanged + { + get { return mGroup.LocationChanged; } + set { mGroup.LocationChanged = value; } + } + + [ProtoMember(15)] + public bool? EnableAutoType + { + get { return mGroup.EnableAutoType; } + set { mGroup.EnableAutoType = value; } + } + + [ProtoMember(16)] + public bool? EnableSearching + { + get { return mGroup.EnableSearching; } + set { mGroup.EnableSearching = value; } + } + + [ProtoMember(17, OverwriteList = true)] + public byte[] LastTopVisibleEntry + { + get { return mGroup.LastTopVisibleEntry.UuidBytes; } + set { mGroup.LastTopVisibleEntry = new PwUuid(value); } + } + + [ProtoMember(18)] + public PwGroupGroupListBuffer Groups + { + get { return mGroups; } + } + + [ProtoMember(19)] + public PwGroupEntryListBuffer Entries + { + get { return mEntries; } + } + } + + private abstract class PwObjectListBufferBase : IEnumerable + where TData : class, KeePassLib.Interfaces.IDeepCloneable + { + #region Serialization + private PwObjectList mObjectList; + + protected PwObjectListBufferBase(PwObjectList objectList) + { + mObjectList = objectList; + } + + protected abstract TDataBuffer CreateBuffer(TData item); + #endregion + + #region Deserialization + protected PwObjectListBufferBase() + { + mObjectList = new PwObjectList(); + } + + public PwObjectList ObjectList { get { return mObjectList; } } + + public abstract void Add(TDataBuffer item); + #endregion + + public IEnumerator GetEnumerator() + { + foreach (var item in mObjectList) + { + yield return CreateBuffer(item); + } + } + + System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() + { + return GetEnumerator(); + } + } + + [ProtoContract] + private class PwGroupGroupListBuffer : PwObjectListBufferBase + { + #region Serialization + private PwGroup mGroup; + public PwGroupGroupListBuffer(PwGroup group) + : base(group.Groups) + { + mGroup = group; + } + + protected override PwGroupBuffer CreateBuffer(PwGroup item) + { + return new PwGroupBuffer(item); + } + #endregion + + #region Deserialization + public override void Add(PwGroupBuffer item) + { + mGroup.AddGroup(item.Group, true); + } + #endregion + } + + [ProtoContract] + private class PwGroupEntryListBuffer : PwObjectListBufferBase + { + #region Serialization + private PwGroup mGroup; + public PwGroupEntryListBuffer(PwGroup group) + : base(group.Entries) + { + mGroup = group; + } + + protected override PwEntryBuffer CreateBuffer(PwEntry item) + { + return new PwEntryBuffer(item); + } + #endregion + + #region Deserialization + public override void Add(PwEntryBuffer item) + { + mGroup.AddEntry(item.Entry, true); + } + #endregion + } + + [ProtoContract] + private class PwEntryListBuffer : PwObjectListBufferBase + { + #region Serialization + public PwEntryListBuffer(PwObjectList entryList) + : base(entryList) + { + } + + protected override PwEntryBuffer CreateBuffer(PwEntry item) + { + return new PwEntryBuffer(item); + } + #endregion + + #region Deserialization + private PwEntryListBuffer() + : base() + { + } + + public override void Add(PwEntryBuffer item) + { + ObjectList.Add(item.Entry); + } + #endregion + } + + [ProtoContract] + private class PwEntryBuffer + { + #region Serialization + private readonly PwEntry mEntry; + private ProtectedStandardFieldDictionaryBuffer mEntryStandardStrings; + private ProtectedCustomFieldDictionaryBuffer mEntryCustomStrings; + private NamedProtectedBinaryListBuffer mEntryBinaries; + + public PwEntryBuffer(PwEntry entry) + { + mEntry = entry; + } + + [ProtoBeforeSerialization] + private void BeforeSerialization(SerializationContext context) + { + var bufferContext = (BufferContext)context.Context; + + // ProtectedStringDictionaryBuffer nver gets its own ProtoBeforeSerialization called as it's a list of objects rather than an object itself + List> customFields; + mEntryStandardStrings = new ProtectedStandardFieldDictionaryBuffer(mEntry.Strings, (int)mEntry.Strings.UCount, bufferContext, out customFields); + mEntryCustomStrings = new ProtectedCustomFieldDictionaryBuffer(customFields); + mEntryBinaries = new NamedProtectedBinaryListBuffer(mEntry.Binaries, (int)mEntry.Binaries.UCount, bufferContext); + } + #endregion + + #region Deserialization + private PwEntryBuffer() + { + mEntry = new PwEntry(false, false); + mEntryStandardStrings = new ProtectedStandardFieldDictionaryBuffer(mEntry.Strings); + mEntryCustomStrings = new ProtectedCustomFieldDictionaryBuffer(mEntry.Strings); + mEntryBinaries = new NamedProtectedBinaryListBuffer(mEntry.Binaries); + } + + public PwEntry Entry { get { return mEntry; } } + #endregion + + [ProtoMember(1, OverwriteList = true)] + public byte[] Uuid + { + get { return mEntry.Uuid.UuidBytes; } + set { mEntry.SetUuid(new PwUuid(value), false); } + } + + [ProtoMember(2)] + public PwIcon IconId + { + get { return mEntry.IconId; } + set { mEntry.IconId = value; } + } + + [ProtoMember(3, OverwriteList = true)] + public byte[] CustomIconUuid + { + get { return mEntry.CustomIconUuid.UuidBytes; } + set { mEntry.CustomIconUuid = new PwUuid(value); } + } + + [ProtoMember(4)] + public int ForegroundColor + { + get { return mEntry.ForegroundColor.ToArgb(); } + set { mEntry.ForegroundColor = Color.FromArgb(value); } + } + + [ProtoMember(5)] + public int BackgroundColor + { + get { return mEntry.BackgroundColor.ToArgb(); } + set { mEntry.BackgroundColor = Color.FromArgb(value); } + } + + [ProtoMember(6)] + public string OverrideUrl + { + get { return mEntry.OverrideUrl; } + set { mEntry.OverrideUrl = value; } + } + + [ProtoMember(7)] + public IList Tags + { + get { return mEntry.Tags; } + } + + [ProtoMember(8)] + public DateTime LastModificationTime + { + get { return mEntry.LastModificationTime; } + set { mEntry.LastModificationTime = value; } + } + + [ProtoMember(9)] + public DateTime CreationTime + { + get { return mEntry.CreationTime; } + set { mEntry.CreationTime = value; } + } + + [ProtoMember(10)] + public DateTime LastAccessTime + { + get { return mEntry.LastAccessTime; } + set { mEntry.LastAccessTime = value; } + } + + [ProtoMember(11)] + public DateTime ExpiryTime + { + get { return mEntry.ExpiryTime; } + set { mEntry.ExpiryTime = value; } + } + + [ProtoMember(12)] + public bool Expires + { + get { return mEntry.Expires; } + set { mEntry.Expires = value; } + } + + [ProtoMember(13)] + public ulong UsageCount + { + get { return mEntry.UsageCount; } + set { mEntry.UsageCount = value; } + } + + [ProtoMember(14)] + public DateTime LocationChanged + { + get { return mEntry.LocationChanged; } + set { mEntry.LocationChanged = value; } + } + + [ProtoMember(15)] + public ProtectedStandardFieldDictionaryBuffer StandardStrings + { + get { return mEntryStandardStrings; } + } + + [ProtoMember(16)] + public ProtectedCustomFieldDictionaryBuffer CustomStrings + { + get { return mEntryCustomStrings; } + } + + [ProtoMember(17, AsReference = true)] + public NamedProtectedBinaryListBuffer Binaries + { + get { return mEntryBinaries; } + } + + [ProtoMember(18)] + public AutoTypeConfigBuffer AutoType + { + get { return new AutoTypeConfigBuffer(mEntry.AutoType); } + set { mEntry.AutoType = value.AutoTypeConfig; } + } + + [ProtoMember(19)] + public PwEntryListBuffer History + { + get { return new PwEntryListBuffer(mEntry.History); } + set { mEntry.History = value.ObjectList; } + } + + } + + private abstract class ProtectedStringDictionaryBuffer : IEnumerable> + { + #region Serialization + private List> mProtectedStringBuffers; + + /// + /// Serialisation constructor. Reads strings from dictionary, does not write to it + /// + protected ProtectedStringDictionaryBuffer(int capacity) + { + mProtectedStringBuffers = new List>(capacity); + } + + protected void AddStringField(TKey key, ProtectedString value, bool? overrideProtect) + { + mProtectedStringBuffers.Add(new KeyValuePair(key, new ProtectedStringBuffer(value, overrideProtect))); + } + + public IEnumerator> GetEnumerator() + { + return mProtectedStringBuffers.GetEnumerator(); + } + + System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() + { + return GetEnumerator(); + } + #endregion + + #region Deserialization + private readonly ProtectedStringDictionary mDictionary; + + /// + /// Deerialisation constructor. Writes strings to dictionary, does read from it + /// + protected ProtectedStringDictionaryBuffer(ProtectedStringDictionary dictionary) + { + mDictionary = dictionary; + } + + public void Add(KeyValuePair item) + { + mDictionary.Set(GetFieldName(item.Key), item.Value.ProtectedString); + } + + protected abstract string GetFieldName(TKey key); + + #endregion + } + + [ProtoContract] + private class ProtectedCustomFieldDictionaryBuffer : ProtectedStringDictionaryBuffer + { + public ProtectedCustomFieldDictionaryBuffer(List> entryStrings) + : base(entryStrings.Count) + { + foreach (var kvp in entryStrings) + { + System.Diagnostics.Debug.Assert(!PwDefs.IsStandardField(kvp.Key)); + AddStringField(kvp.Key, kvp.Value, null); + } + } + + public ProtectedCustomFieldDictionaryBuffer(ProtectedStringDictionary dictionary) + : base(dictionary) + { } + + protected override string GetFieldName(string key) + { + return key; + } + } + + [ProtoContract] + private class ProtectedStandardFieldDictionaryBuffer : ProtectedStringDictionaryBuffer + { + public enum StandardField + { + Title, + UserName, + Password, + Url, + Notes + } + + public ProtectedStandardFieldDictionaryBuffer(IEnumerable> entryStrings, int entryStringCount, BufferContext context, + out List> customFields) // Perf optimisation - return the custom fields so we don't have to determine them again + : base(entryStringCount) + { + customFields = new List>(entryStringCount); + + var database = context.Database; + + foreach (var kvp in entryStrings) + { + var field = GetField(kvp.Key); + + if (field.HasValue) + { + // Logic from KdbxFile.Write + + bool? overrideProtect = null; + // Adjust memory protection setting (which might be different + // from the database default, e.g. due to an import which + // didn't specify the correct setting) + switch (field.Value) + { + case StandardField.Title: + overrideProtect = database.MemoryProtection.ProtectTitle; + break; + case StandardField.UserName: + overrideProtect = database.MemoryProtection.ProtectUserName; + break; + case StandardField.Password: + overrideProtect = database.MemoryProtection.ProtectPassword; + break; + case StandardField.Url: + overrideProtect = database.MemoryProtection.ProtectUrl; + break; + case StandardField.Notes: + overrideProtect = database.MemoryProtection.ProtectNotes; + break; + } + + AddStringField(field.Value, kvp.Value, overrideProtect); + } + else + { + customFields.Add(kvp); + } + } + } + + private static StandardField? GetField(string fieldName) + { + switch (fieldName) + { + case PwDefs.TitleField: + return StandardField.Title; + case PwDefs.UserNameField: + return StandardField.UserName; + case PwDefs.PasswordField: + return StandardField.Password; + case PwDefs.UrlField: + return StandardField.Url; + case PwDefs.NotesField: + return StandardField.Notes; + + default: + System.Diagnostics.Debug.Assert(!PwDefs.IsStandardField(fieldName)); + return null; + } + } + + public ProtectedStandardFieldDictionaryBuffer(ProtectedStringDictionary dictionary) + : base(dictionary) + { } + + protected override string GetFieldName(StandardField key) + { + switch (key) + { + case StandardField.Title: + return PwDefs.TitleField; + case StandardField.UserName: + return PwDefs.UserNameField; + case StandardField.Password: + return PwDefs.PasswordField; + case StandardField.Url: + return PwDefs.UrlField; + case StandardField.Notes: + return PwDefs.NotesField; + default: + throw new ArgumentOutOfRangeException(); + } + } + } + + [ProtoContract] + private class ProtectedStringBuffer + { + #region Serialisation + private ProtectedString mProtectedString; + + public ProtectedStringBuffer(ProtectedString protectedString, bool? overrideProtect) + { + mProtectedString = protectedString; + IsProtected = overrideProtect.GetValueOrDefault(mProtectedString.IsProtected); + } + + [ProtoBeforeSerialization] + private void BeforeSerialization(SerializationContext context) + { + if (IsProtected) + { + Value = mProtectedString.ReadXorredString(((BufferContext)context.Context).RandomStream); + } + else + { + Value = mProtectedString.ReadUtf8(); + } + } + #endregion + + #region Deserialisation + private ProtectedStringBuffer() + { + } + + [ProtoAfterDeserialization] + private void AfterDeserialization(SerializationContext context) + { + if (IsProtected) + { + byte[] pbPad = ((BufferContext)context.Context).RandomStream.GetRandomBytes((uint)Value.Length); + mProtectedString = new ProtectedString(IsProtected, new XorredBuffer(Value, pbPad)); + } + else + { + mProtectedString = new ProtectedString(IsProtected, Value); + } + } + + public ProtectedString ProtectedString { get { return mProtectedString; } } + + #endregion + + [ProtoMember(1)] + public bool IsProtected; + + [ProtoMember(2, OverwriteList = true)] + public byte[] Value; + } + + [ProtoContract] + private class NamedProtectedBinaryListBuffer : IEnumerable + { + #region Serialisation + private readonly List mNamedBinaries; + + public NamedProtectedBinaryListBuffer(IEnumerable> binaries, int binariesCount, BufferContext context) + { + mNamedBinaries = new List(binariesCount); + foreach (var kvp in binaries) + { + NamedProtectedBinaryBuffer namedProtectedBinaryBuffer; + if (!context.BinaryPool.TryGetValue(kvp.Value, out namedProtectedBinaryBuffer)) + { + // Hasn't been put in the pool yet, so create it + namedProtectedBinaryBuffer = new NamedProtectedBinaryBuffer(kvp); + context.BinaryPool.Add(kvp.Value, namedProtectedBinaryBuffer); + } + mNamedBinaries.Add(namedProtectedBinaryBuffer); + } + } + + public IEnumerator GetEnumerator() + { + return mNamedBinaries.GetEnumerator(); + } + + System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() + { + return GetEnumerator(); + } + #endregion + + #region Deserialization + private readonly ProtectedBinaryDictionary mBinaryDictionary; + + public NamedProtectedBinaryListBuffer(ProtectedBinaryDictionary binaryDictionary) + { + mBinaryDictionary = binaryDictionary; + } + + public void Add(NamedProtectedBinaryBuffer item) + { + mBinaryDictionary.Set(item.Name, item.ProtectedBinary); + } + #endregion + } + + [ProtoContract] + private class NamedProtectedBinaryBuffer + { + #region Serialization + private ProtectedBinary mProtectedBinary; + public NamedProtectedBinaryBuffer(KeyValuePair namedBinary) + { + Name = namedBinary.Key; + mProtectedBinary = namedBinary.Value; + IsProtected = mProtectedBinary.IsProtected; + } + + [ProtoBeforeSerialization] + private void BeforeSerialization(SerializationContext context) + { + if (IsProtected) + { + Value = mProtectedBinary.ReadXorredData(((BufferContext)context.Context).RandomStream); + } + else + { + Value = mProtectedBinary.ReadData(); + } + } + #endregion + + #region Deserialisation + private NamedProtectedBinaryBuffer() + { + } + + [ProtoAfterDeserialization] + private void AfterDeserialization(SerializationContext context) + { + if (IsProtected) + { + byte[] pbPad = ((BufferContext)context.Context).RandomStream.GetRandomBytes((uint)Value.Length); + mProtectedBinary = new ProtectedBinary(IsProtected, new XorredBuffer(Value, pbPad)); + } + else + { + mProtectedBinary = new ProtectedBinary(IsProtected, Value); + } + } + + public ProtectedBinary ProtectedBinary { get { return mProtectedBinary; } } + + #endregion + + [ProtoMember(1)] + public string Name; + + [ProtoMember(2)] + public bool IsProtected; + + [ProtoMember(3, OverwriteList = true)] + public byte[] Value; + } + + [ProtoContract] + private class AutoTypeConfigBuffer + { + private readonly AutoTypeAssociationsBuffer mAutoTypeAssociationsBuffer; + #region Serialization + private AutoTypeConfig mAutoTypeConfig; + public AutoTypeConfigBuffer(AutoTypeConfig autoTypeConfig) + { + mAutoTypeConfig = autoTypeConfig; + mAutoTypeAssociationsBuffer = new AutoTypeAssociationsBuffer(mAutoTypeConfig); + } + #endregion + + #region Deserialization + private AutoTypeConfigBuffer() + { + mAutoTypeConfig = new AutoTypeConfig(); + mAutoTypeAssociationsBuffer = new AutoTypeAssociationsBuffer(mAutoTypeConfig); + } + + public AutoTypeConfig AutoTypeConfig { get { return mAutoTypeConfig; } } + #endregion + + [ProtoMember(1)] + public bool Enabled + { + get { return mAutoTypeConfig.Enabled; } + set { mAutoTypeConfig.Enabled = value; } + } + + [ProtoMember(2)] + public AutoTypeObfuscationOptions ObfuscationOptions + { + get { return mAutoTypeConfig.ObfuscationOptions; } + set { mAutoTypeConfig.ObfuscationOptions = value; } + } + + [ProtoMember(3)] + public string DefaultSequence + { + get { return mAutoTypeConfig.DefaultSequence; } + set { mAutoTypeConfig.DefaultSequence = value; } + } + + [ProtoMember(4)] + public AutoTypeAssociationsBuffer Associations + { + get { return mAutoTypeAssociationsBuffer; } + } + } + + [ProtoContract] + private class AutoTypeAssociationsBuffer : IEnumerable + { + #region Serialization + private AutoTypeConfig mAutoTypeConfig; + + public AutoTypeAssociationsBuffer(AutoTypeConfig autoTypeConfig) + { + mAutoTypeConfig = autoTypeConfig; + } + + public IEnumerator GetEnumerator() + { + foreach (var autoTypeAssociation in mAutoTypeConfig.Associations) + { + yield return new AutoTypeAssociationBuffer(autoTypeAssociation); + } + } + + System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() + { + return GetEnumerator(); + } + #endregion + + #region Deserialization + public void Add(AutoTypeAssociationBuffer value) + { + mAutoTypeConfig.Add(value.AutoTypeAssociation); + } + #endregion + } + + [ProtoContract] + private class AutoTypeAssociationBuffer + { + #region Serialization + private AutoTypeAssociation mAutoTypeAssociation; + + public AutoTypeAssociationBuffer(AutoTypeAssociation autoTypeAssociation) + { + mAutoTypeAssociation = autoTypeAssociation; + } + #endregion + + #region Deserialization + private AutoTypeAssociationBuffer() + { + mAutoTypeAssociation = new AutoTypeAssociation(); + } + + public AutoTypeAssociation AutoTypeAssociation { get { return mAutoTypeAssociation; } } + #endregion + + [ProtoMember(1)] + public string WindowName + { + get { return mAutoTypeAssociation.WindowName; } + set { mAutoTypeAssociation.WindowName = value; } + } + + [ProtoMember(2)] + public string Sequence + { + get { return mAutoTypeAssociation.Sequence; } + set { mAutoTypeAssociation.Sequence = value; } + } + } + } +} diff --git a/src/ProtoBuf/protobuf-net.dll b/src/ProtoBuf/protobuf-net.dll new file mode 100644 index 0000000000000000000000000000000000000000..adc83a911a00ff572038764d4a74daa449c21bca GIT binary patch literal 187392 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

RRIBB-U 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 literal 0 HcmV?d00001 diff --git a/src/ProtoBuf/protobuf-net.xml b/src/ProtoBuf/protobuf-net.xml new file mode 100644 index 00000000..3451e38c --- /dev/null +++ b/src/ProtoBuf/protobuf-net.xml @@ -0,0 +1,2747 @@ + + + + protobuf-net + + + +

+ Provides support for common .NET types that do not have a direct representation + in protobuf, using the definitions from bcl.proto + + + + + Creates a new instance of the specified type, bypassing the constructor. + + The type to create + The new instance + If the platform does not support constructor-skipping + + + + Writes a TimeSpan to a protobuf stream + + + + + Parses a TimeSpan from a protobuf stream + + + + + Parses a DateTime from a protobuf stream + + + + + Writes a DateTime to a protobuf stream + + + + + Parses a decimal from a protobuf stream + + + + + Writes a decimal to a protobuf stream + + + + + Writes a Guid to a protobuf stream + + + + + Parses a Guid from a protobuf stream + + + + + Reads an *implementation specific* bundled .NET object, including (as options) type-metadata, identity/re-use, etc. + + + + + Writes an *implementation specific* bundled .NET object, including (as options) type-metadata, identity/re-use, etc. + + + + + Optional behaviours that introduce .NET-specific functionality + + + + + No special behaviour + + + + + Enables full object-tracking/full-graph support. + + + + + Embeds the type information into the stream, allowing usage with types not known in advance. + + + + + If false, the constructor for the type is bypassed during deserialization, meaning any field initializers + or other initialization code is skipped. + + + + + Should the object index be reserved, rather than creating an object promptly + + + + + Provides a simple buffer-based implementation of an extension object. + + + + + Provides addition capability for supporting unexpected fields during + protocol-buffer serialization/deserialization. This allows for loss-less + round-trip/merge, even when the data is not fully understood. + + + + + Requests a stream into which any unexpected fields can be persisted. + + A new stream suitable for storing data. + + + + Indicates that all unexpected fields have now been stored. The + implementing class is responsible for closing the stream. If + "commit" is not true the data may be discarded. + + The stream originally obtained by BeginAppend. + True if the append operation completed successfully. + + + + Requests a stream of the unexpected fields previously stored. + + A prepared stream of the unexpected fields. + + + + Indicates that all unexpected fields have now been read. The + implementing class is responsible for closing the stream. + + The stream originally obtained by BeginQuery. + + + + Requests the length of the raw binary stream; this is used + when serializing sub-entities to indicate the expected size. + + The length of the binary stream representing unexpected data. + + + Specifies a method on the root-contract in an hierarchy to be invoked before serialization. + + + Specifies a method on the root-contract in an hierarchy to be invoked after serialization. + + + Specifies a method on the root-contract in an hierarchy to be invoked before deserialization. + + + Specifies a method on the root-contract in an hierarchy to be invoked after deserialization. + + + + Pushes a null reference onto the stack. Note that this should only + be used to return a null (or set a variable to null); for null-tests + use BranchIfTrue / BranchIfFalse. + + + + + Creates a new "using" block (equivalent) around a variable; + the variable must exist, and note that (unlike in C#) it is + the variables *final* value that gets disposed. If you need + *original* disposal, copy your variable first. + + It is the callers responsibility to ensure that the variable's + scope fully-encapsulates the "using"; if not, the variable + may be re-used (and thus re-assigned) unexpectedly. + + + + + Sub-format to use when serializing/deserializing data + + + + + Uses the default encoding for the data-type. + + + + + When applied to signed integer-based data (including Decimal), this + indicates that zigzag variant encoding will be used. This means that values + with small magnitude (regardless of sign) take a small amount + of space to encode. + + + + + When applied to signed integer-based data (including Decimal), this + indicates that two's-complement variant encoding will be used. + This means that any -ve number will take 10 bytes (even for 32-bit), + so should only be used for compatibility. + + + + + When applied to signed integer-based data (including Decimal), this + indicates that a fixed amount of space will be used. + + + + + When applied to a sub-message, indicates that the value should be treated + as group-delimited. + + + + + Simple base class for supporting unexpected fields allowing + for loss-less round-tips/merge, even if the data is not understod. + The additional fields are (by default) stored in-memory in a buffer. + + As an example of an alternative implementation, you might + choose to use the file system (temporary files) as the back-end, tracking + only the paths [such an object would ideally be IDisposable and use + a finalizer to ensure that the files are removed]. + + + + + Indicates that the implementing type has support for protocol-buffer + extensions. + + Can be implemented by deriving from Extensible. + + + + Retrieves the extension object for the current + instance, optionally creating it if it does not already exist. + + Should a new extension object be + created if it does not already exist? + The extension object if it exists (or was created), or null + if the extension object does not exist or is not available. + The createIfMissing argument is false during serialization, + and true during deserialization upon encountering unexpected fields. + + + + Retrieves the extension object for the current + instance, optionally creating it if it does not already exist. + + Should a new extension object be + created if it does not already exist? + The extension object if it exists (or was created), or null + if the extension object does not exist or is not available. + The createIfMissing argument is false during serialization, + and true during deserialization upon encountering unexpected fields. + + + + Provides a simple, default implementation for extension support, + optionally creating it if it does not already exist. Designed to be called by + classes implementing . + + Should a new extension object be + created if it does not already exist? + The extension field to check (and possibly update). + The extension object if it exists (or was created), or null + if the extension object does not exist or is not available. + The createIfMissing argument is false during serialization, + and true during deserialization upon encountering unexpected fields. + + + + Appends the value as an additional (unexpected) data-field for the instance. + Note that for non-repeated sub-objects, this equates to a merge operation; + for repeated sub-objects this adds a new instance to the set; for simple + values the new value supercedes the old value. + + Note that appending a value does not remove the old value from + the stream; avoid repeatedly appending values for the same field. + The type of the value to append. + The extensible object to append the value to. + The field identifier; the tag should not be defined as a known data-field for the instance. + The value to append. + + + + Appends the value as an additional (unexpected) data-field for the instance. + Note that for non-repeated sub-objects, this equates to a merge operation; + for repeated sub-objects this adds a new instance to the set; for simple + values the new value supercedes the old value. + + Note that appending a value does not remove the old value from + the stream; avoid repeatedly appending values for the same field. + The data-type of the field. + The data-format to use when encoding the value. + The extensible object to append the value to. + The field identifier; the tag should not be defined as a known data-field for the instance. + The value to append. + + + + Queries an extensible object for an additional (unexpected) data-field for the instance. + The value returned is the composed value after merging any duplicated content; if the + value is "repeated" (a list), then use GetValues instead. + + The data-type of the field. + The extensible object to obtain the value from. + The field identifier; the tag should not be defined as a known data-field for the instance. + The effective value of the field, or the default value if not found. + + + + Queries an extensible object for an additional (unexpected) data-field for the instance. + The value returned is the composed value after merging any duplicated content; if the + value is "repeated" (a list), then use GetValues instead. + + The data-type of the field. + The extensible object to obtain the value from. + The field identifier; the tag should not be defined as a known data-field for the instance. + The data-format to use when decoding the value. + The effective value of the field, or the default value if not found. + + + + Queries an extensible object for an additional (unexpected) data-field for the instance. + The value returned (in "value") is the composed value after merging any duplicated content; + if the value is "repeated" (a list), then use GetValues instead. + + The data-type of the field. + The effective value of the field, or the default value if not found. + The extensible object to obtain the value from. + The field identifier; the tag should not be defined as a known data-field for the instance. + True if data for the field was present, false otherwise. + + + + Queries an extensible object for an additional (unexpected) data-field for the instance. + The value returned (in "value") is the composed value after merging any duplicated content; + if the value is "repeated" (a list), then use GetValues instead. + + The data-type of the field. + The effective value of the field, or the default value if not found. + The extensible object to obtain the value from. + The field identifier; the tag should not be defined as a known data-field for the instance. + The data-format to use when decoding the value. + True if data for the field was present, false otherwise. + + + + Queries an extensible object for an additional (unexpected) data-field for the instance. + The value returned (in "value") is the composed value after merging any duplicated content; + if the value is "repeated" (a list), then use GetValues instead. + + The data-type of the field. + The effective value of the field, or the default value if not found. + The extensible object to obtain the value from. + The field identifier; the tag should not be defined as a known data-field for the instance. + The data-format to use when decoding the value. + Allow tags that are present as part of the definition; for example, to query unknown enum values. + True if data for the field was present, false otherwise. + + + + Queries an extensible object for an additional (unexpected) data-field for the instance. + Each occurrence of the field is yielded separately, making this usage suitable for "repeated" + (list) fields. + + The extended data is processed lazily as the enumerator is iterated. + The data-type of the field. + The extensible object to obtain the value from. + The field identifier; the tag should not be defined as a known data-field for the instance. + An enumerator that yields each occurrence of the field. + + + + Queries an extensible object for an additional (unexpected) data-field for the instance. + Each occurrence of the field is yielded separately, making this usage suitable for "repeated" + (list) fields. + + The extended data is processed lazily as the enumerator is iterated. + The data-type of the field. + The extensible object to obtain the value from. + The field identifier; the tag should not be defined as a known data-field for the instance. + The data-format to use when decoding the value. + An enumerator that yields each occurrence of the field. + + + + Queries an extensible object for an additional (unexpected) data-field for the instance. + The value returned (in "value") is the composed value after merging any duplicated content; + if the value is "repeated" (a list), then use GetValues instead. + + The data-type of the field. + The model to use for configuration. + The effective value of the field, or the default value if not found. + The extensible object to obtain the value from. + The field identifier; the tag should not be defined as a known data-field for the instance. + The data-format to use when decoding the value. + Allow tags that are present as part of the definition; for example, to query unknown enum values. + True if data for the field was present, false otherwise. + + + + Queries an extensible object for an additional (unexpected) data-field for the instance. + Each occurrence of the field is yielded separately, making this usage suitable for "repeated" + (list) fields. + + The extended data is processed lazily as the enumerator is iterated. + The model to use for configuration. + The data-type of the field. + The extensible object to obtain the value from. + The field identifier; the tag should not be defined as a known data-field for the instance. + The data-format to use when decoding the value. + An enumerator that yields each occurrence of the field. + + + + Appends the value as an additional (unexpected) data-field for the instance. + Note that for non-repeated sub-objects, this equates to a merge operation; + for repeated sub-objects this adds a new instance to the set; for simple + values the new value supercedes the old value. + + Note that appending a value does not remove the old value from + the stream; avoid repeatedly appending values for the same field. + The model to use for configuration. + The data-format to use when encoding the value. + The extensible object to append the value to. + The field identifier; the tag should not be defined as a known data-field for the instance. + The value to append. + + + + This class acts as an internal wrapper allowing us to do a dynamic + methodinfo invoke; an't put into Serializer as don't want on public + API; can't put into Serializer<T> since we need to invoke + accross classes, which isn't allowed in Silverlight) + + + + + All this does is call GetExtendedValuesTyped with the correct type for "instance"; + this ensures that we don't get issues with subclasses declaring conflicting types - + the caller must respect the fields defined for the type they pass in. + + + + + All this does is call GetExtendedValuesTyped with the correct type for "instance"; + this ensures that we don't get issues with subclasses declaring conflicting types - + the caller must respect the fields defined for the type they pass in. + + + + + Not all frameworks are created equal (fx1.1 vs fx2.0, + micro-framework, compact-framework, + silverlight, etc). This class simply wraps up a few things that would + otherwise make the real code unnecessarily messy, providing fallback + implementations if necessary. + + + + + Intended to be a direct map to regular TypeCode, but: + - with missing types + - existing on WinRT + + + + + Specifies the method used to infer field tags for members of the type + under consideration. Tags are deduced using the invariant alphabetic + sequence of the members' names; this makes implicit field tags very brittle, + and susceptible to changes such as field names (normally an isolated + change). + + + + + No members are serialized implicitly; all members require a suitable + attribute such as [ProtoMember]. This is the recmomended mode for + most scenarios. + + + + + Public properties and fields are eligible for implicit serialization; + this treats the public API as a contract. Ordering beings from ImplicitFirstTag. + + + + + Public and non-public fields are eligible for implicit serialization; + this acts as a state/implementation serializer. Ordering beings from ImplicitFirstTag. + + + + + Represents the set of serialization callbacks to be used when serializing/deserializing a type. + + + + Called before serializing an instance + + + Called before deserializing an instance + + + Called after serializing an instance + + + Called after deserializing an instance + + + + True if any callback is set, else False + + + + + Represents a type at runtime for use with protobuf, allowing the field mappings (etc) to be defined + + + + + Get the name of the type being represented + + + + + Adds a known sub-type to the inheritance model + + + + + Adds a known sub-type to the inheritance model + + + + + Assigns the callbacks to use during serialiation/deserialization. + + The method (or null) called before serialization begins. + The method (or null) called when serialization is complete. + The method (or null) called before deserialization begins (or when a new instance is created during deserialization). + The method (or null) called when deserialization is complete. + The set of callbacks. + + + + Assigns the callbacks to use during serialiation/deserialization. + + The name of the method (or null) called before serialization begins. + The name of the method (or null) called when serialization is complete. + The name of the method (or null) called before deserialization begins (or when a new instance is created during deserialization). + The name of the method (or null) called when deserialization is complete. + The set of callbacks. + + + + Designate a factory-method to use to create instances of this type + + + + + Designate a factory-method to use to create instances of this type + + + + + Throws an exception if the type has been made immutable + + + + + Adds a member (by name) to the MetaType + + + + + Adds a member (by name) to the MetaType, returning the ValueMember rather than the fluent API. + This is otherwise identical to Add. + + + + + Adds a member (by name) to the MetaType + + + + + Performs serialization of this type via a surrogate; all + other serialization options are ignored and handled + by the surrogate's configuration. + + + + + Adds a set of members (by name) to the MetaType + + + + + Adds a member (by name) to the MetaType + + + + + Adds a member (by name) to the MetaType, including an itemType and defaultType for representing lists + + + + + Adds a member (by name) to the MetaType, including an itemType and defaultType for representing lists, returning the ValueMember rather than the fluent API. + This is otherwise identical to Add. + + + + + Returns the ValueMember instances associated with this type + + + + + Returns the SubType instances associated with this type + + + + + Compiles the serializer for this type; this is *not* a full + standalone compile, but can significantly boost performance + while allowing additional types to be added. + + An in-place compile can access non-public types / members + + + + Gets the base-type for this type + + + + + When used to compile a model, should public serialization/deserialzation methods + be included for this type? + + + + + Should this type be treated as a reference by default? + + + + + Indicates whether the current type has defined callbacks + + + + + Indicates whether the current type has defined subtypes + + + + + Returns the set of callbacks defined for this type + + + + + Gets or sets the name of this contract. + + + + + The runtime type that the meta-type represents + + + + + Gets or sets whether the type should use a parameterless constructor (the default), + or whether the type should skip the constructor completely. This option is not supported + on compact-framework. + + + + + The concrete type to create when a new instance of this type is needed; this may be useful when dealing + with dynamic proxies, or with interface-based APIs + + + + + Returns the ValueMember that matchs a given field number, or null if not found + + + + + Returns the ValueMember that matchs a given member (property/field), or null if not found + + + + + Gets or sets a value indicating that an enum should be treated directly as an int/short/etc, rather + than enforcing .proto enum rules. This is useful *in particul* for [Flags] enums. + + + + + Gets or sets a value indicating that this type should NOT be treated as a list, even if it has + familiar list-like characteristics (enumerable, add, etc) + + + + + Provides protobuf serialization support for a number of types that can be defined at runtime + + + + + Provides protobuf serialization support for a number of types + + + + + Resolve a System.Type to the compiler-specific type + + + + + Resolve a System.Type to the compiler-specific type + + + + + This is the more "complete" version of Serialize, which handles single instances of mapped types. + The value is written as a complete field, including field-header and (for sub-objects) a + length-prefix + In addition to that, this provides support for: + - basic values; individual int / string / Guid / etc + - IEnumerable sequences of any type handled by TrySerializeAuxiliaryType + + + + + + Writes a protocol-buffer representation of the given instance to the supplied stream. + + The existing instance to be serialized (cannot be null). + The destination stream to write to. + + + + Writes a protocol-buffer representation of the given instance to the supplied stream. + + The existing instance to be serialized (cannot be null). + The destination stream to write to. + Additional information about this serialization operation. + + + + Writes a protocol-buffer representation of the given instance to the supplied writer. + + The existing instance to be serialized (cannot be null). + The destination writer to write to. + + + + Applies a protocol-buffer stream to an existing instance (or null), using length-prefixed + data - useful with network IO. + + The type being merged. + The existing instance to be modified (can be null). + The binary stream to apply to the instance (cannot be null). + How to encode the length prefix. + The tag used as a prefix to each record (only used with base-128 style prefixes). + The updated instance; this may be different to the instance argument if + either the original instance was null, or the stream defines a known sub-type of the + original instance. + + + + Applies a protocol-buffer stream to an existing instance (or null), using length-prefixed + data - useful with network IO. + + The type being merged. + The existing instance to be modified (can be null). + The binary stream to apply to the instance (cannot be null). + How to encode the length prefix. + The tag used as a prefix to each record (only used with base-128 style prefixes). + Used to resolve types on a per-field basis. + The updated instance; this may be different to the instance argument if + either the original instance was null, or the stream defines a known sub-type of the + original instance. + + + + Applies a protocol-buffer stream to an existing instance (or null), using length-prefixed + data - useful with network IO. + + The type being merged. + The existing instance to be modified (can be null). + The binary stream to apply to the instance (cannot be null). + How to encode the length prefix. + The tag used as a prefix to each record (only used with base-128 style prefixes). + Used to resolve types on a per-field basis. + Returns the number of bytes consumed by this operation (includes length-prefix overheads and any skipped data). + The updated instance; this may be different to the instance argument if + either the original instance was null, or the stream defines a known sub-type of the + original instance. + + + + Reads a sequence of consecutive length-prefixed items from a stream, using + either base-128 or fixed-length prefixes. Base-128 prefixes with a tag + are directly comparable to serializing multiple items in succession + (use the tag to emulate the implicit behavior + when serializing a list/array). When a tag is + specified, any records with different tags are silently omitted. The + tag is ignored. The tag is ignores for fixed-length prefixes. + + The binary stream containing the serialized records. + The prefix style used in the data. + The tag of records to return (if non-positive, then no tag is + expected and all records are returned). + On a field-by-field basis, the type of object to deserialize (can be null if "type" is specified). + The type of object to deserialize (can be null if "resolver" is specified). + The sequence of deserialized objects. + + + + Reads a sequence of consecutive length-prefixed items from a stream, using + either base-128 or fixed-length prefixes. Base-128 prefixes with a tag + are directly comparable to serializing multiple items in succession + (use the tag to emulate the implicit behavior + when serializing a list/array). When a tag is + specified, any records with different tags are silently omitted. The + tag is ignored. The tag is ignores for fixed-length prefixes. + + The binary stream containing the serialized records. + The prefix style used in the data. + The tag of records to return (if non-positive, then no tag is + expected and all records are returned). + On a field-by-field basis, the type of object to deserialize (can be null if "type" is specified). + The type of object to deserialize (can be null if "resolver" is specified). + The sequence of deserialized objects. + Additional information about this serialization operation. + + + + Reads a sequence of consecutive length-prefixed items from a stream, using + either base-128 or fixed-length prefixes. Base-128 prefixes with a tag + are directly comparable to serializing multiple items in succession + (use the tag to emulate the implicit behavior + when serializing a list/array). When a tag is + specified, any records with different tags are silently omitted. The + tag is ignored. The tag is ignores for fixed-length prefixes. + + The type of object to deserialize. + The binary stream containing the serialized records. + The prefix style used in the data. + The tag of records to return (if non-positive, then no tag is + expected and all records are returned). + The sequence of deserialized objects. + + + + Reads a sequence of consecutive length-prefixed items from a stream, using + either base-128 or fixed-length prefixes. Base-128 prefixes with a tag + are directly comparable to serializing multiple items in succession + (use the tag to emulate the implicit behavior + when serializing a list/array). When a tag is + specified, any records with different tags are silently omitted. The + tag is ignored. The tag is ignores for fixed-length prefixes. + + The type of object to deserialize. + The binary stream containing the serialized records. + The prefix style used in the data. + The tag of records to return (if non-positive, then no tag is + expected and all records are returned). + The sequence of deserialized objects. + Additional information about this serialization operation. + + + + Writes a protocol-buffer representation of the given instance to the supplied stream, + with a length-prefix. This is useful for socket programming, + as DeserializeWithLengthPrefix can be used to read the single object back + from an ongoing stream. + + The type being serialized. + The existing instance to be serialized (cannot be null). + How to encode the length prefix. + The destination stream to write to. + The tag used as a prefix to each record (only used with base-128 style prefixes). + + + + Writes a protocol-buffer representation of the given instance to the supplied stream, + with a length-prefix. This is useful for socket programming, + as DeserializeWithLengthPrefix can be used to read the single object back + from an ongoing stream. + + The type being serialized. + The existing instance to be serialized (cannot be null). + How to encode the length prefix. + The destination stream to write to. + The tag used as a prefix to each record (only used with base-128 style prefixes). + Additional information about this serialization operation. + + + + Applies a protocol-buffer stream to an existing instance (which may be null). + + The type (including inheritance) to consider. + The existing instance to be modified (can be null). + The binary stream to apply to the instance (cannot be null). + The updated instance; this may be different to the instance argument if + either the original instance was null, or the stream defines a known sub-type of the + original instance. + + + + Applies a protocol-buffer stream to an existing instance (which may be null). + + The type (including inheritance) to consider. + The existing instance to be modified (can be null). + The binary stream to apply to the instance (cannot be null). + The updated instance; this may be different to the instance argument if + either the original instance was null, or the stream defines a known sub-type of the + original instance. + Additional information about this serialization operation. + + + + Applies a protocol-buffer stream to an existing instance (which may be null). + + The type (including inheritance) to consider. + The existing instance to be modified (can be null). + The binary stream to apply to the instance (cannot be null). + The number of bytes to consume. + The updated instance; this may be different to the instance argument if + either the original instance was null, or the stream defines a known sub-type of the + original instance. + + + + Applies a protocol-buffer stream to an existing instance (which may be null). + + The type (including inheritance) to consider. + The existing instance to be modified (can be null). + The binary stream to apply to the instance (cannot be null). + The number of bytes to consume (or -1 to read to the end of the stream). + The updated instance; this may be different to the instance argument if + either the original instance was null, or the stream defines a known sub-type of the + original instance. + Additional information about this serialization operation. + + + + Applies a protocol-buffer reader to an existing instance (which may be null). + + The type (including inheritance) to consider. + The existing instance to be modified (can be null). + The reader to apply to the instance (cannot be null). + The updated instance; this may be different to the instance argument if + either the original instance was null, or the stream defines a known sub-type of the + original instance. + + + + This is the more "complete" version of Deserialize, which handles single instances of mapped types. + The value is read as a complete field, including field-header and (for sub-objects) a + length-prefix..kmc + + In addition to that, this provides support for: + - basic values; individual int / string / Guid / etc + - IList sets of any type handled by TryDeserializeAuxiliaryType + + + + + Creates a new runtime model, to which the caller + can add support for a range of types. A model + can be used "as is", or can be compiled for + optimal performance. + + + + + Applies common proxy scenarios, resolving the actual type to consider + + + + + Indicates whether the supplied type is explicitly modelled by the model + + + + + Provides the key that represents a given type in the current model. + The type is also normalized for proxies at the same time. + + + + + Provides the key that represents a given type in the current model. + + + + + Writes a protocol-buffer representation of the given instance to the supplied stream. + + Represents the type (including inheritance) to consider. + The existing instance to be serialized (cannot be null). + The destination stream to write to. + + + + Applies a protocol-buffer stream to an existing instance (which may be null). + + Represents the type (including inheritance) to consider. + The existing instance to be modified (can be null). + The binary stream to apply to the instance (cannot be null). + The updated instance; this may be different to the instance argument if + either the original instance was null, or the stream defines a known sub-type of the + original instance. + + + + Create a deep clone of the supplied instance; any sub-items are also cloned. + + + + + Indicates that while an inheritance tree exists, the exact type encountered was not + specified in that hierarchy and cannot be processed. + + + + + Indicates that the given type was not expected, and cannot be processed. + + + + + Indicates that the given type cannot be constructed; it may still be possible to + deserialize into existing instances. + + + + + Returns true if the type supplied is either a recognised contract type, + or a *list* of a recognised contract type. + + Note that primitives always return false, even though the engine + will, if forced, try to serialize such + True if this type is recognised as a serializable entity, else false + + + + Returns true if the type supplied is a basic type with inbuilt handling, + a recognised contract type, or a *list* of a basic / contract type. + + + + + Returns true if the type supplied is a basic type with inbuilt handling, + or a *list* of a basic type with inbuilt handling + + + + + Suggest a .proto definition for the given type + + The type to generate a .proto definition for, or null to generate a .proto that represents the entire model + The .proto definition as a string + + + + Creates a new IFormatter that uses protocol-buffer [de]serialization. + + A new IFormatter to be used during [de]serialization. + The type of object to be [de]deserialized by the formatter. + + + + Used to provide custom services for writing and parsing type names when using dynamic types. Both parsing and formatting + are provided on a single API as it is essential that both are mapped identically at all times. + + + + + Indicates the type of callback to be used + + + + + Invoked before an object is serialized + + + + + Invoked after an object is serialized + + + + + Invoked before an object is deserialized (or when a new instance is created) + + + + + Invoked after an object is deserialized + + + + + Returns a sequence of the Type instances that can be + processed by this model. + + + + + Suggest a .proto definition for the given type + + The type to generate a .proto definition for, or null to generate a .proto that represents the entire model + The .proto definition as a string + + + + Adds support for an additional type in this model, optionally + appplying inbuilt patterns. If the type is already known to the + model, the existing type is returned **without** applying + any additional behaviour. + + Inbuilt patterns include: + [ProtoContract]/[ProtoMember(n)] + [DataContract]/[DataMember(Order=n)] + [XmlType]/[XmlElement(Order=n)] + [On{Des|S}erializ{ing|ed}] + ShouldSerialize*/*Specified + + The type to be supported + Whether to apply the inbuilt configuration patterns (via attributes etc), or + just add the type with no additional configuration (the type must then be manually configured). + The MetaType representing this type, allowing + further configuration. + + + + Verifies that the model is still open to changes; if not, an exception is thrown + + + + + Prevents further changes to this model + + + + + Provides the key that represents a given type in the current model. + + + + + Writes a protocol-buffer representation of the given instance to the supplied stream. + + Represents the type (including inheritance) to consider. + The existing instance to be serialized (cannot be null). + The destination stream to write to. + + + + Applies a protocol-buffer stream to an existing instance (which may be null). + + Represents the type (including inheritance) to consider. + The existing instance to be modified (can be null). + The binary stream to apply to the instance (cannot be null). + The updated instance; this may be different to the instance argument if + either the original instance was null, or the stream defines a known sub-type of the + original instance. + + + + Compiles the serializers individually; this is *not* a full + standalone compile, but can significantly boost performance + while allowing additional types to be added. + + An in-place compile can access non-public types / members + + + + Fully compiles the current model into a static-compiled model instance + + A full compilation is restricted to accessing public types / members + An instance of the newly created compiled type-model + + + + Fully compiles the current model into a static-compiled serialization dll + (the serialization dll still requires protobuf-net for support services). + + A full compilation is restricted to accessing public types / members + The name of the TypeModel class to create + The path for the new dll + An instance of the newly created compiled type-model + + + + Fully compiles the current model into a static-compiled serialization dll + (the serialization dll still requires protobuf-net for support services). + + A full compilation is restricted to accessing public types / members + An instance of the newly created compiled type-model + + + + Designate a factory-method to use to create instances of any type; note that this only affect types seen by the serializer *after* setting the factory. + + + + + Global default that + enables/disables automatic tag generation based on the existing name / order + of the defined members. See + for usage and important warning / explanation. + You must set the global default before attempting to serialize/deserialize any + impacted type. + + + + + Global default that determines whether types are considered serializable + if they have [DataContract] / [XmlType]. With this enabled, ONLY + types marked as [ProtoContract] are added automatically. + + + + + Global switch that enables or disables the implicit + handling of "zero defaults"; meanning: if no other default is specified, + it assumes bools always default to false, integers to zero, etc. + + If this is disabled, no such assumptions are made and only *explicit* + default values are processed. This is enabled by default to + preserve similar logic to v1. + + + + + Global switch that determines whether types with a .ToString() and a Parse(string) + should be serialized as strings. + + + + + The default model, used to support ProtoBuf.Serializer + + + + + Obtains the MetaType associated with a given Type for the current model, + allowing additional configuration. + + + + + Should serializers be compiled on demand? It may be useful + to disable this for debugging purposes. + + + + + Should support for unexpected types be added automatically? + If false, an exception is thrown when unexpected types + are encountered. + + + + + The amount of time to wait if there are concurrent metadata access operations + + + + + If a lock-contention is detected, this event signals the *owner* of the lock responsible for the blockage, indicating + what caused the problem; this is only raised if the lock-owning code successfully completes. + + + + + Represents configuration options for compiling a model to + a standalone assembly. + + + + + Import framework options from an existing type + + + + + The TargetFrameworkAttribute FrameworkName value to burn into the generated assembly + + + + + The TargetFrameworkAttribute FrameworkDisplayName value to burn into the generated assembly + + + + + The name of the TypeModel class to create + + + + + The path for the new dll + + + + + The runtime version for the generated assembly + + + + + The runtime version for the generated assembly + + + + + The acecssibility of the generated serializer + + + + + Type accessibility + + + + + Available to all callers + + + + + Available to all callers in the same assembly, or assemblies specified via [InternalsVisibleTo(...)] + + + + + Contains the stack-trace of the owning code when a lock-contention scenario is detected + + + + + The stack-trace of the code that owned the lock when a lock-contention scenario occurred + + + + + Event-type that is raised when a lock-contention scenario is detected + + + + + Represents an inherited type in a type hierarchy. + + + + + Creates a new SubType instance. + + The field-number that is used to encapsulate the data (as a nested + message) for the derived dype. + The sub-type to be considered. + Specific encoding style to use; in particular, Grouped can be used to avoid buffering, but is not the default. + + + + The field-number that is used to encapsulate the data (as a nested + message) for the derived dype. + + + + + The sub-type to be considered. + + + + + Event arguments needed to perform type-formatting functions; this could be resolving a Type to a string suitable for serialization, or could + be requesting a Type from a string. If no changes are made, a default implementation will be used (from the assembly-qualified names). + + + + + The type involved in this map; if this is initially null, a Type is expected to be provided for the string in FormattedName. + + + + + The formatted-name involved in this map; if this is initially null, a formatted-name is expected from the type in Type. + + + + + Delegate type used to perform type-formatting functions; the sender originates as the type-model. + + + + + Represents a member (property/field) that is mapped to a protobuf field + + + + + Creates a new ValueMember instance + + + + + Creates a new ValueMember instance + + + + + Specifies methods for working with optional data members. + + Provides a method (null for none) to query whether this member should + be serialized; it must be of the form "bool {Method}()". The member is only serialized if the + method returns true. + Provides a method (null for none) to indicate that a member was + deserialized; it must be of the form "void {Method}(bool)", and will be called with "true" + when data is found. + + + + The number that identifies this member in a protobuf stream + + + + + Gets the member (field/property) which this member relates to. + + + + + Within a list / array / etc, the type of object for each item in the list (especially useful with ArrayList) + + + + + The underlying type of the member + + + + + For abstract types (IList etc), the type of concrete object to create (if required) + + + + + The type the defines the member + + + + + The default value of the item (members with this value will not be serialized) + + + + + Specifies the rules used to process the field; this is used to determine the most appropriate + wite-type, but also to describe subtypes within that wire-type (such as SignedVariant) + + + + + Indicates whether this field should follow strict encoding rules; this means (for example) that if a "fixed32" + is encountered when "variant" is defined, then it will fail (throw an exception) when parsing. Note that + when serializing the defined type is always used. + + + + + Indicates whether this field should use packed encoding (which can save lots of space for repeated primitive values). + This option only applies to list/array data of primitive types (int, double, etc). + + + + + Indicates whether this field should *repace* existing values (the default is false, meaning *append*). + This option only applies to list/array data. + + + + + Indicates whether this field is mandatory. + + + + + Enables full object-tracking/full-graph support. + + + + + Embeds the type information into the stream, allowing usage with types not known in advance. + + + + + Gets the logical name for this member in the schema (this is not critical for binary serialization, but may be used + when inferring a schema). + + + + + Should lists have extended support for null values? Note this makes the serialization less efficient. + + + + + Specifies the type of prefix that should be applied to messages. + + + + + No length prefix is applied to the data; the data is terminated only be the end of the stream. + + + + + A base-128 length prefix is applied to the data (efficient for short messages). + + + + + A fixed-length (little-endian) length prefix is applied to the data (useful for compatibility). + + + + + A fixed-length (big-endian) length prefix is applied to the data (useful for compatibility). + + + + + Indicates that a type is defined for protocol-buffer serialization. + + + + + Gets or sets the defined name of the type. + + + + + Gets or sets the fist offset to use with implicit field tags; + only uesd if ImplicitFields is set. + + + + + If specified, alternative contract markers (such as markers for XmlSerailizer or DataContractSerializer) are ignored. + + + + + If specified, do NOT treat this type as a list, even if it looks like one. + + + + + Gets or sets the mechanism used to automatically infer field tags + for members. This option should be used in advanced scenarios only. + Please review the important notes against the ImplicitFields enumeration. + + + + + Enables/disables automatic tag generation based on the existing name / order + of the defined members. This option is not used for members marked + with ProtoMemberAttribute, as intended to provide compatibility with + WCF serialization. WARNING: when adding new fields you must take + care to increase the Order for new elements, otherwise data corruption + may occur. + + If not explicitly specified, the default is assumed from Serializer.GlobalOptions.InferTagFromName. + + + + Has a InferTagFromName value been explicitly set? if not, the default from the type-model is assumed. + + + + + Specifies an offset to apply to [DataMember(Order=...)] markers; + this is useful when working with mex-generated classes that have + a different origin (usually 1 vs 0) than the original data-contract. + + This value is added to the Order of each member. + + + + + If true, the constructor for the type is bypassed during deserialization, meaning any field initializers + or other initialization code is skipped. + + + + + Should this type be treated as a reference by default? Please also see the implications of this, + as recorded on ProtoMemberAttribute.AsReference + + + + + Used to define protocol-buffer specific behavior for + enumerated values. + + + + + Indicates whether this instance has a customised value mapping + + true if a specific value is set + + + + Gets or sets the specific value to use for this enum during serialization. + + + + + Gets or sets the defined name of the enum, as used in .proto + (this name is not used during serialization). + + + + + Indicates an error during serialization/deserialization of a proto stream. + + + + Creates a new ProtoException instance. + + + Creates a new ProtoException instance. + + + Creates a new ProtoException instance. + + + Creates a new ProtoException instance. + + + + Indicates that a member should be excluded from serialization; this + is only normally used when using implict fields. + + + + + Indicates that a member should be excluded from serialization; this + is only normally used when using implict fields. This allows + ProtoIgnoreAttribute usage + even for partial classes where the individual members are not + under direct control. + + + + + Creates a new ProtoPartialIgnoreAttribute instance. + + Specifies the member to be ignored. + + + + The name of the member to be ignored. + + + + + Indicates the known-types to support for an individual + message. This serializes each level in the hierarchy as + a nested message to retain wire-compatibility with + other protocol-buffer implementations. + + + + + Creates a new instance of the ProtoIncludeAttribute. + + The unique index (within the type) that will identify this data. + The additional type to serialize/deserialize. + + + + Creates a new instance of the ProtoIncludeAttribute. + + The unique index (within the type) that will identify this data. + The additional type to serialize/deserialize. + + + + Gets the unique index (within the type) that will identify this data. + + + + + Gets the additional type to serialize/deserialize. + + + + + Gets the additional type to serialize/deserialize. + + + + + Specifies whether the inherited sype's sub-message should be + written with a length-prefix (default), or with group markers. + + + + + Declares a member to be used in protocol-buffer serialization, using + the given Tag. A DataFormat may be used to optimise the serialization + format (for instance, using zigzag encoding for negative numbers, or + fixed-length encoding for large values. + + + + + Compare with another ProtoMemberAttribute for sorting purposes + + + + + Compare with another ProtoMemberAttribute for sorting purposes + + + + + Creates a new ProtoMemberAttribute instance. + + Specifies the unique tag used to identify this member within the type. + + + + Gets or sets the original name defined in the .proto; not used + during serialization. + + + + + Gets or sets the data-format to be used when encoding this value. + + + + + Gets the unique tag used to identify this member within the type. + + + + + Gets or sets a value indicating whether this member is mandatory. + + + + + Gets a value indicating whether this member is packed. + This option only applies to list/array data of primitive types (int, double, etc). + + + + + Indicates whether this field should *repace* existing values (the default is false, meaning *append*). + This option only applies to list/array data. + + + + + Enables full object-tracking/full-graph support. + + + + + Embeds the type information into the stream, allowing usage with types not known in advance. + + + + + Gets or sets a value indicating whether this member is packed (lists/arrays). + + + + + Additional (optional) settings that control serialization of members + + + + + Default; no additional options + + + + + Indicates that repeated elements should use packed (length-prefixed) encoding + + + + + Indicates that the given item is required + + + + + Enables full object-tracking/full-graph support + + + + + Embeds the type information into the stream, allowing usage with types not known in advance + + + + + Indicates whether this field should *repace* existing values (the default is false, meaning *append*). + This option only applies to list/array data. + + + + + Determines whether the types AsReferenceDefault value is used, or whether this member's AsReference should be used + + + + + Declares a member to be used in protocol-buffer serialization, using + the given Tag and MemberName. This allows ProtoMemberAttribute usage + even for partial classes where the individual members are not + under direct control. + A DataFormat may be used to optimise the serialization + format (for instance, using zigzag encoding for negative numbers, or + fixed-length encoding for large values. + + + + + Creates a new ProtoMemberAttribute instance. + + Specifies the unique tag used to identify this member within the type. + Specifies the member to be serialized. + + + + The name of the member to be serialized. + + + + + A stateful reader, used to read a protobuf stream. Typical usage would be (sequentially) to call + ReadFieldHeader and (after matching the field) an appropriate Read* method. + + + + + Creates a new reader against a stream + + The source stream + The model to use for serialization; this can be null, but this will impair the ability to deserialize sub-objects + Additional context about this serialization operation + + + + Creates a new reader against a stream + + The source stream + The model to use for serialization; this can be null, but this will impair the ability to deserialize sub-objects + Additional context about this serialization operation + The number of bytes to read, or -1 to read until the end of the stream + + + + Releases resources used by the reader, but importantly does not Dispose the + underlying stream; in many typical use-cases the stream is used for different + processes, so it is assumed that the consumer will Dispose their stream separately. + + + + + Reads an unsigned 32-bit integer from the stream; supported wire-types: Variant, Fixed32, Fixed64 + + + + + Reads a signed 16-bit integer from the stream: Variant, Fixed32, Fixed64, SignedVariant + + + + + Reads an unsigned 16-bit integer from the stream; supported wire-types: Variant, Fixed32, Fixed64 + + + + + Reads an unsigned 8-bit integer from the stream; supported wire-types: Variant, Fixed32, Fixed64 + + + + + Reads a signed 8-bit integer from the stream; supported wire-types: Variant, Fixed32, Fixed64, SignedVariant + + + + + Reads a signed 32-bit integer from the stream; supported wire-types: Variant, Fixed32, Fixed64, SignedVariant + + + + + Reads a signed 64-bit integer from the stream; supported wire-types: Variant, Fixed32, Fixed64, SignedVariant + + + + + Reads a string from the stream (using UTF8); supported wire-types: String + + + + + Throws an exception indication that the given value cannot be mapped to an enum. + + + + + Reads a double-precision number from the stream; supported wire-types: Fixed32, Fixed64 + + + + + Reads (merges) a sub-message from the stream, internally calling StartSubItem and EndSubItem, and (in between) + parsing the message in accordance with the model associated with the reader + + + + + Makes the end of consuming a nested message in the stream; the stream must be either at the correct EndGroup + marker, or all fields of the sub-message must have been consumed (in either case, this means ReadFieldHeader + should return zero) + + + + + Begins consuming a nested message in the stream; supported wire-types: StartGroup, String + + The token returned must be help and used when callining EndSubItem + + + + Reads a field header from the stream, setting the wire-type and retuning the field number. If no + more fields are available, then 0 is returned. This methods respects sub-messages. + + + + + Looks ahead to see whether the next field in the stream is what we expect + (typically; what we've just finished reading - for example ot read successive list items) + + + + + Compares the streams current wire-type to the hinted wire-type, updating the reader if necessary; for example, + a Variant may be updated to SignedVariant. If the hinted wire-type is unrelated then no change is made. + + + + + Verifies that the stream's current wire-type is as expected, or a specialized sub-type (for example, + SignedVariant) - in which case the current wire-type is updated. Otherwise an exception is thrown. + + + + + Discards the data for the current field. + + + + + Reads an unsigned 64-bit integer from the stream; supported wire-types: Variant, Fixed32, Fixed64 + + + + + Reads a single-precision number from the stream; supported wire-types: Fixed32, Fixed64 + + + + + Reads a boolean value from the stream; supported wire-types: Variant, Fixed32, Fixed64 + + + + + + Reads a byte-sequence from the stream, appending them to an existing byte-sequence (which can be null); supported wire-types: String + + + + + Reads the length-prefix of a message from a stream without buffering additional data, allowing a fixed-length + reader to be created. + + + + + Reads a little-endian encoded integer. An exception is thrown if the data is not all available. + + + + + Reads a big-endian encoded integer. An exception is thrown if the data is not all available. + + + + + Reads a varint encoded integer. An exception is thrown if the data is not all available. + + + + + Reads a string (of a given lenth, in bytes) directly from the source into a pre-existing buffer. An exception is thrown if the data is not all available. + + + + + Reads a given number of bytes directly from the source. An exception is thrown if the data is not all available. + + + + + Reads a string (of a given lenth, in bytes) directly from the source. An exception is thrown if the data is not all available. + + + + + Reads the length-prefix of a message from a stream without buffering additional data, allowing a fixed-length + reader to be created. + + + + The number of bytes consumed; 0 if no data available + + + + Copies the current field into the instance as extension data + + + + + Indicates whether the reader still has data remaining in the current sub-item, + additionally setting the wire-type for the next field if there is more data. + This is used when decoding packed data. + + + + + Utility method, not intended for public use; this helps maintain the root object is complex scenarios + + + + + Reads a Type from the stream, using the model's DynamicTypeFormatting if appropriate; supported wire-types: String + + + + + Merge two objects using the details from the current reader; this is used to change the type + of objects when an inheritance relationship is discovered later than usual during deserilazation. + + + + + Gets the number of the field being processed. + + + + + Indicates the underlying proto serialization format on the wire. + + + + + Gets / sets a flag indicating whether strings should be checked for repetition; if + true, any repeated UTF-8 byte sequence will result in the same String instance, rather + than a second instance of the same string. Enabled by default. Note that this uses + a custom interner - the system-wide string interner is not used. + + + + + Addition information about this deserialization operation. + + + + + Returns the position of the current reader (note that this is not necessarily the same as the position + in the underlying stream, if multiple readers are used on the same stream) + + + + + Get the TypeModel associated with this reader + + + + + Represents an output stream for writing protobuf data. + + Why is the API backwards (static methods with writer arguments)? + See: http://marcgravell.blogspot.com/2010/03/last-will-be-first-and-first-will-be.html + + + + + Write an encapsulated sub-object, using the supplied unique key (reprasenting a type). + + The object to write. + The key that uniquely identifies the type within the model. + The destination. + + + + Write an encapsulated sub-object, using the supplied unique key (reprasenting a type) - but the + caller is asserting that this relationship is non-recursive; no recursion check will be + performed. + + The object to write. + The key that uniquely identifies the type within the model. + The destination. + + + + Writes a field-header, indicating the format of the next data we plan to write. + + + + + Writes a byte-array to the stream; supported wire-types: String + + + + + Writes a byte-array to the stream; supported wire-types: String + + + + + Indicates the start of a nested record. + + The instance to write. + The destination. + A token representing the state of the stream; this token is given to EndSubItem. + + + + Indicates the end of a nested record. + + The token obtained from StartubItem. + The destination. + + + + Creates a new writer against a stream + + The destination stream + The model to use for serialization; this can be null, but this will impair the ability to serialize sub-objects + Additional context about this serialization operation + + + + Flushes data to the underlying stream, and releases any resources. The underlying stream is *not* disposed + by this operation. + + + + + Writes any buffered data (if possible) to the underlying stream. + + The writer to flush + It is not always possible to fully flush, since some sequences + may require values to be back-filled into the byte-stream. + + + + Writes an unsigned 32-bit integer to the stream; supported wire-types: Variant, Fixed32, Fixed64 + + + + + Writes a string to the stream; supported wire-types: String + + + + + Writes an unsigned 64-bit integer to the stream; supported wire-types: Variant, Fixed32, Fixed64 + + + + + Writes a signed 64-bit integer to the stream; supported wire-types: Variant, Fixed32, Fixed64, SignedVariant + + + + + Writes an unsigned 16-bit integer to the stream; supported wire-types: Variant, Fixed32, Fixed64 + + + + + Writes a signed 16-bit integer to the stream; supported wire-types: Variant, Fixed32, Fixed64, SignedVariant + + + + + Writes an unsigned 16-bit integer to the stream; supported wire-types: Variant, Fixed32, Fixed64 + + + + + Writes an unsigned 8-bit integer to the stream; supported wire-types: Variant, Fixed32, Fixed64 + + + + + Writes a signed 8-bit integer to the stream; supported wire-types: Variant, Fixed32, Fixed64, SignedVariant + + + + + Writes a signed 32-bit integer to the stream; supported wire-types: Variant, Fixed32, Fixed64, SignedVariant + + + + + Writes a double-precision number to the stream; supported wire-types: Fixed32, Fixed64 + + + + + Writes a single-precision number to the stream; supported wire-types: Fixed32, Fixed64 + + + + + Throws an exception indicating that the given enum cannot be mapped to a serialized value. + + + + + Writes a boolean to the stream; supported wire-types: Variant, Fixed32, Fixed64 + + + + + Copies any extension data stored for the instance to the underlying stream + + + + + Used for packed encoding; indicates that the next field should be skipped rather than + a field header written. Note that the field number must match, else an exception is thrown + when the attempt is made to write the (incorrect) field. The wire-type is taken from the + subsequent call to WriteFieldHeader. Only primitive types can be packed. + + + + + Specifies a known root object to use during reference-tracked serialization + + + + + Writes a Type to the stream, using the model's DynamicTypeFormatting if appropriate; supported wire-types: String + + + + + Addition information about this serialization operation. + + + + + Get the TypeModel associated with this writer + + + + + Additional information about a serialization operation + + + + + Convert a SerializationContext to a StreamingContext + + + + + Convert a StreamingContext to a SerializationContext + + + + + Gets or sets a user-defined object containing additional information about this serialization/deserialization operation. + + + + + A default SerializationContext, with minimal information. + + + + + Gets or sets the source or destination of the transmitted data. + + + + + Provides protocol-buffer serialization capability for concrete, attributed types. This + is a *default* model, but custom serializer models are also supported. + + + Protocol-buffer serialization is a compact binary format, designed to take + advantage of sparse data and knowledge of specific data types; it is also + extensible, allowing a type to be deserialized / merged even if some data is + not recognised. + + + + + The field number that is used as a default when serializing/deserializing a list of objects. + The data is treated as repeated message with field number 1. + + + + + Suggest a .proto definition for the given type + + The type to generate a .proto definition for + The .proto definition as a string + + + + Create a deep clone of the supplied instance; any sub-items are also cloned. + + + + + Applies a protocol-buffer stream to an existing instance. + + The type being merged. + The existing instance to be modified (can be null). + The binary stream to apply to the instance (cannot be null). + The updated instance; this may be different to the instance argument if + either the original instance was null, or the stream defines a known sub-type of the + original instance. + + + + Creates a new instance from a protocol-buffer stream + + The type to be created. + The binary stream to apply to the new instance (cannot be null). + A new, initialized instance. + + + + Writes a protocol-buffer representation of the given instance to the supplied stream. + + The existing instance to be serialized (cannot be null). + The destination stream to write to. + + + + Serializes a given instance and deserializes it as a different type; + this can be used to translate between wire-compatible objects (where + two .NET types represent the same data), or to promote/demote a type + through an inheritance hierarchy. + + No assumption of compatibility is made between the types. + The type of the object being copied. + The type of the new object to be created. + The existing instance to use as a template. + A new instane of type TNewType, with the data from TOldType. + + + + Writes a protocol-buffer representation of the given instance to the supplied SerializationInfo. + + The type being serialized. + The existing instance to be serialized (cannot be null). + The destination SerializationInfo to write to. + + + + Writes a protocol-buffer representation of the given instance to the supplied SerializationInfo. + + The type being serialized. + The existing instance to be serialized (cannot be null). + The destination SerializationInfo to write to. + Additional information about this serialization operation. + + + + Writes a protocol-buffer representation of the given instance to the supplied XmlWriter. + + The type being serialized. + The existing instance to be serialized (cannot be null). + The destination XmlWriter to write to. + + + + Applies a protocol-buffer from an XmlReader to an existing instance. + + The type being merged. + The existing instance to be modified (cannot be null). + The XmlReader containing the data to apply to the instance (cannot be null). + + + + Applies a protocol-buffer from a SerializationInfo to an existing instance. + + The type being merged. + The existing instance to be modified (cannot be null). + The SerializationInfo containing the data to apply to the instance (cannot be null). + + + + Applies a protocol-buffer from a SerializationInfo to an existing instance. + + The type being merged. + The existing instance to be modified (cannot be null). + The SerializationInfo containing the data to apply to the instance (cannot be null). + Additional information about this serialization operation. + + + + Precompiles the serializer for a given type. + + + + + Creates a new IFormatter that uses protocol-buffer [de]serialization. + + The type of object to be [de]deserialized by the formatter. + A new IFormatter to be used during [de]serialization. + + + + Reads a sequence of consecutive length-prefixed items from a stream, using + either base-128 or fixed-length prefixes. Base-128 prefixes with a tag + are directly comparable to serializing multiple items in succession + (use the tag to emulate the implicit behavior + when serializing a list/array). When a tag is + specified, any records with different tags are silently omitted. The + tag is ignored. The tag is ignores for fixed-length prefixes. + + The type of object to deserialize. + The binary stream containing the serialized records. + The prefix style used in the data. + The tag of records to return (if non-positive, then no tag is + expected and all records are returned). + The sequence of deserialized objects. + + + + Creates a new instance from a protocol-buffer stream that has a length-prefix + on data (to assist with network IO). + + The type to be created. + The binary stream to apply to the new instance (cannot be null). + How to encode the length prefix. + A new, initialized instance. + + + + Creates a new instance from a protocol-buffer stream that has a length-prefix + on data (to assist with network IO). + + The type to be created. + The binary stream to apply to the new instance (cannot be null). + How to encode the length prefix. + The expected tag of the item (only used with base-128 prefix style). + A new, initialized instance. + + + + Applies a protocol-buffer stream to an existing instance, using length-prefixed + data - useful with network IO. + + The type being merged. + The existing instance to be modified (can be null). + The binary stream to apply to the instance (cannot be null). + How to encode the length prefix. + The updated instance; this may be different to the instance argument if + either the original instance was null, or the stream defines a known sub-type of the + original instance. + + + + Writes a protocol-buffer representation of the given instance to the supplied stream, + with a length-prefix. This is useful for socket programming, + as DeserializeWithLengthPrefix/MergeWithLengthPrefix can be used to read the single object back + from an ongoing stream. + + The type being serialized. + The existing instance to be serialized (cannot be null). + How to encode the length prefix. + The destination stream to write to. + + + + Writes a protocol-buffer representation of the given instance to the supplied stream, + with a length-prefix. This is useful for socket programming, + as DeserializeWithLengthPrefix/MergeWithLengthPrefix can be used to read the single object back + from an ongoing stream. + + The type being serialized. + The existing instance to be serialized (cannot be null). + How to encode the length prefix. + The destination stream to write to. + The tag used as a prefix to each record (only used with base-128 style prefixes). + + + Indicates the number of bytes expected for the next message. + The stream containing the data to investigate for a length. + The algorithm used to encode the length. + The length of the message, if it could be identified. + True if a length could be obtained, false otherwise. + + + Indicates the number of bytes expected for the next message. + The buffer containing the data to investigate for a length. + The offset of the first byte to read from the buffer. + The number of bytes to read from the buffer. + The algorithm used to encode the length. + The length of the message, if it could be identified. + True if a length could be obtained, false otherwise. + + + + Releases any internal buffers that have been reserved for efficiency; this does not affect any serialization + operations; simply: it can be used (optionally) to release the buffers for garbage collection (at the expense + of having to re-allocate a new buffer for the next operation, rather than re-use prior buffers). + + + + + Provides non-generic access to the default serializer. + + + + + Create a deep clone of the supplied instance; any sub-items are also cloned. + + + + + Writes a protocol-buffer representation of the given instance to the supplied stream. + + The existing instance to be serialized (cannot be null). + The destination stream to write to. + + + + Creates a new instance from a protocol-buffer stream + + The type to be created. + The binary stream to apply to the new instance (cannot be null). + A new, initialized instance. + + + Applies a protocol-buffer stream to an existing instance. + The existing instance to be modified (cannot be null). + The binary stream to apply to the instance (cannot be null). + The updated instance + + + + Writes a protocol-buffer representation of the given instance to the supplied stream, + with a length-prefix. This is useful for socket programming, + as DeserializeWithLengthPrefix/MergeWithLengthPrefix can be used to read the single object back + from an ongoing stream. + + The existing instance to be serialized (cannot be null). + How to encode the length prefix. + The destination stream to write to. + The tag used as a prefix to each record (only used with base-128 style prefixes). + + + + Applies a protocol-buffer stream to an existing instance (or null), using length-prefixed + data - useful with network IO. + + The existing instance to be modified (can be null). + The binary stream to apply to the instance (cannot be null). + How to encode the length prefix. + Used to resolve types on a per-field basis. + The updated instance; this may be different to the instance argument if + either the original instance was null, or the stream defines a known sub-type of the + original instance. + + + + Indicates whether the supplied type is explicitly modelled by the model + + + + + Global switches that change the behavior of protobuf-net + + + + + + + + + + Maps a field-number to a type + + + + + Perform the steps necessary to serialize this data. + + The value to be serialized. + The writer entity that is accumulating the output data. + + + + Perform the steps necessary to deserialize this data. + + The current value, if appropriate. + The reader providing the input data. + The updated / replacement value. + + + Emit the IL necessary to perform the given actions + to serialize this data. + + Details and utilities for the method being generated. + The source of the data to work against; + If the value is only needed once, then LoadValue is sufficient. If + the value is needed multiple times, then note that a "null" + means "the top of the stack", in which case you should create your + own copy - GetLocalWithValue. + + + + Emit the IL necessary to perform the given actions to deserialize this data. + + Details and utilities for the method being generated. + For nested values, the instance holding the values; note + that this is not always provided - a null means not supplied. Since this is always + a variable or argument, it is not necessary to consume this value. + + + + The type that this serializer is intended to work for. + + + + + Indicates whether a Read operation replaces the existing value, or + extends the value. If false, the "value" parameter to Read is + discarded, and should be passed in as null. + + + + + Now all Read operations return a value (although most do); if false no + value should be expected. + + + + + Used to hold particulars relating to nested objects. This is opaque to the caller - simply + give back the token you are given at the end of an object. + + + + + Indicates the encoding used to represent an individual value in a protobuf stream + + + + + Represents an error condition + + + + + Base-128 variant-length encoding + + + + + Fixed-length 8-byte encoding + + + + + Length-variant-prefixed encoding + + + + + Indicates the start of a group + + + + + Indicates the end of a group + + + + + Fixed-length 4-byte encoding + 10 + + + + This is not a formal wire-type in the "protocol buffers" spec, but + denotes a variant integer that should be interpreted using + zig-zag semantics (so -ve numbers aren't a significant overhead) + + + +