Added documentation for most types and members

Author: ilyalukyanov

src/LightningDB/Converters/ConvertFromBytesInstance.cs

@@ -2,20 +2,34 @@
 
 namespace LightningDB.Converters
 {
+    /// <summary>
+    /// Class for converting from a byte array to a concrete type using specified lambda
+    /// </summary>
+    /// <typeparam name="TTo"></typeparam>
     public class ConvertFromBytesInstance<TTo> : IConvertFromBytes<TTo>
     {
         private readonly Func<LightningDatabase, byte[], TTo> _convert;
 
+        /// <summary>
+        /// Creates new instance of ConvertFromBytesInstance
+        /// </summary>
+        /// <param name="convert">Conversion lambda</param>
         public ConvertFromBytesInstance(Func<LightningDatabase, byte[], TTo> convert)
         {
             _convert = convert;
         }
 
-        public Type ConvertFromType
-        {
-            get { return typeof(TTo); }
-        }
+        /// <summary>
+        /// Destination type
+        /// </summary>
+        public Type ConvertFromType { get { return typeof(TTo); } }
 
+        /// <summary>
+        /// Converts a byte array to a destination type.
+        /// </summary>
+        /// <param name="db">Database</param>
+        /// <param name="bytes">Byte array.</param>
+        /// <returns>Converted value.</returns>
         public TTo Convert(LightningDatabase db, byte[] bytes)
         {
             return bytes == null ? default(TTo) : _convert(db, bytes);

src/LightningDB/Converters/ConvertToBytesInstance.cs

@@ -2,20 +2,34 @@
 
 namespace LightningDB.Converters
 {
+    /// <summary>
+    /// Class for conversion using a specified lambda from .NET type to byte array.
+    /// </summary>
+    /// <typeparam name="TFrom">Source type to convert from.</typeparam>
     public class ConvertToBytesInstance<TFrom> : IConvertToBytes<TFrom>
     {
         private readonly Func<LightningDatabase, TFrom, byte[]> _convert;
 
+        /// <summary>
+        /// Creates a new instance of ConvertToBytesInstance.
+        /// </summary>
+        /// <param name="convert">Conversion lambda</param>
         public ConvertToBytesInstance(Func<LightningDatabase, TFrom, byte[]> convert)
         {
             _convert = convert;
         }
 
-        public Type ConvertFromType
-        {
-            get { return typeof(TFrom); }
-        }
+        /// <summary>
+        /// Source type.
+        /// </summary>
+        public Type ConvertFromType { get { return typeof(TFrom); } }
 
+        /// <summary>
+        /// Converts from source type to a byte array.
+        /// </summary>
+        /// <param name="db">Database.</param>
+        /// <param name="instance">Source value.</param>
+        /// <returns>Value converted to a byte array.</returns>
         public byte[] Convert(LightningDatabase db, TFrom instance)
         {
             return _convert(db, instance);

src/LightningDB/Converters/ConverterExtensions.cs

@@ -3,6 +3,9 @@
 
 namespace LightningDB.Converters
 {
+    /// <summary>
+    /// Extension methods for converters and ConverterStore
+    /// </summary>
     public static class ConverterExtensions
     {
         public static void AddConvertToBytes<TFrom>(this ConverterStore store, Func<LightningDatabase, TFrom, byte[]> convert)

src/LightningDB/Converters/ConverterNotFoundException.cs

@@ -2,8 +2,15 @@
 
 namespace LightningDB.Converters
 {
+    /// <summary>
+    /// Thrown when a converter wasn't fount
+    /// </summary>
     public class ConverterNotFoundException : Exception
     {
+        /// <summary>
+        /// Creates a new instance of ConverterNotFoundException
+        /// </summary>
+        /// <param name="type">Type for which the converter wasn't found</param>
         public ConverterNotFoundException(Type type) 
             : base(string.Format("Unable to find converter for {0}", type.FullName))
         {

src/LightningDB/Converters/ConverterStore.cs

@@ -4,6 +4,9 @@
 
 namespace LightningDB.Converters
 {
+    /// <summary>
+    /// Encapsulates collections to store converters used by LightningEnvironment.
+    /// </summary>
     public class ConverterStore
     {
         private readonly IDictionary<Type, object> _convertToBytes = new ConcurrentDictionary<Type, object>(); 

src/LightningDB/Converters/DefaultConverters.cs

@@ -2,8 +2,15 @@
 
 namespace LightningDB.Converters
 {
+    /// <summary>
+    /// Class to setup default converters for LightningEnvironment
+    /// </summary>
     public class DefaultConverters
     {
+        /// <summary>
+        /// Registers predefined list of converters.
+        /// </summary>
+        /// <param name="environment">Environment to register converters in.</param>
         public void RegisterDefault(LightningEnvironment environment)
         {
             var store = environment.ConverterStore;

src/LightningDB/Converters/IConvertFromBytes.cs

@@ -2,9 +2,23 @@
 
 namespace LightningDB.Converters
 {
+    /// <summary>
+    /// Interface for converters from a byte array to a .NET type
+    /// </summary>
+    /// <typeparam name="TTo">Type to convert to</typeparam>
     public interface IConvertFromBytes<TTo>
     {
+        /// <summary>
+        /// Destination type.
+        /// </summary>
         Type ConvertFromType { get; }
+
+        /// <summary>
+        /// Convertes from a byte array to a .NET type
+        /// </summary>
+        /// <param name="db">Database</param>
+        /// <param name="bytes">Value bytes</param>
+        /// <returns>Converted value</returns>
         TTo Convert(LightningDatabase db, byte[] bytes);
     }
 }

src/LightningDB/Converters/IConvertToBytes.cs

@@ -2,9 +2,23 @@
 
 namespace LightningDB.Converters
 {
+    /// <summary>
+    /// Interface for converter from .NET type to a byte array.
+    /// </summary>
+    /// <typeparam name="TConvertFrom">Type to convert from/</typeparam>
     public interface IConvertToBytes<TConvertFrom>
     {
+        /// <summary>
+        /// Source type
+        /// </summary>
         Type ConvertFromType { get; }
+
+        /// <summary>
+        /// Converts value from .NET type to a byte array
+        /// </summary>
+        /// <param name="db">Database</param>
+        /// <param name="instance">Value</param>
+        /// <returns>Value as a byte array.</returns>
         byte[] Convert(LightningDatabase db, TConvertFrom instance);
     }
 }

src/LightningDB/CursorDeleteOption.cs

@@ -1,7 +1,13 @@
 namespace LightningDB
 {
+    /// <summary>
+    /// Cursor delete operation options
+    /// </summary>
     public enum CursorDeleteOption
     {
+        /// <summary>
+        /// No special behavior
+        /// </summary>
         None = 0,
 
         /// <summary>

src/LightningDB/CursorGetByOperation.cs

@@ -2,17 +2,28 @@
 using System.Collections.Generic;
 namespace LightningDB
 {
+    /// <summary>
+    /// Converter class for pairs obtained via cursor
+    /// </summary>
     public class CursorGetByOperation
     {
         private readonly LightningCursor _cur;
         private readonly KeyValuePair<byte[], byte[]>? _pair;
 
+        /// <summary>
+        /// Creates new instance of CursorGetByOperation.
+        /// </summary>
+        /// <param name="cur">Cursor.</param>
+        /// <param name="pair">Key-value byte arrays pair</param>
         public CursorGetByOperation(LightningCursor cur, KeyValuePair<byte[], byte[]>? pair)
         {
             _cur = cur;
             _pair = pair;
         }
 
+        /// <summary>
+        /// Does key-value pair exist in database.
+        /// </summary>
         public bool PairExists { get { return _pair.HasValue; } }
 
         private void EnsurePairExists()
@@ -21,20 +32,36 @@ private void EnsurePairExists()
                 throw new InvalidOperationException("Pair doesn't exist");
         }
 
+        /// <summary>
+        /// Converts database key to a concrete type
+        /// </summary>
+        /// <typeparam name="TKey">Type to convert key to</typeparam>
+        /// <returns>Converted key value.</returns>
         public TKey Key<TKey>()
         {
             this.EnsurePairExists();
 
             return _cur.FromBytes<TKey>(_pair.Value.Key);
         }
 
+        /// <summary>
+        /// Converts database value to a concrete type.
+        /// </summary>
+        /// <typeparam name="TValue">Type to convert value to.</typeparam>
+        /// <returns>Converted value.</returns>
         public TValue Value<TValue>()
         {
             this.EnsurePairExists();
 
             return _cur.FromBytes<TValue>(_pair.Value.Value);
         }
 
+        /// <summary>
+        /// Convert key-value pair to concrete types
+        /// </summary>
+        /// <typeparam name="TKey">Key type.</typeparam>
+        /// <typeparam name="TValue">Value type.</typeparam>
+        /// <returns>Pair of converted key and value.</returns>
         public KeyValuePair<TKey, TValue> Pair<TKey, TValue>()
         {
             return new KeyValuePair<TKey, TValue>(this.Key<TKey>(), this.Value<TValue>());