Inital Commit

Author: Hugo Bonacci

Bson/BsonAnonymousTypeParser.cs

@@ -0,0 +1,131 @@
+using System;
+using System.Collections.Generic;
+using System.Reflection;
+using System.Text.RegularExpressions;
+
+namespace CSMongo.Bson {
+
+    //<summary>
+    //Class designed to use an AnonymousType as a template
+    //for a return value using a BsonObject for a data source
+    //Really shouldn't be used for anything else since it
+    //only works with the BsonObjects 
+    internal class BsonAnonymousTypeParser {
+
+        #region Constructors
+
+        /// <summary>
+        /// Creates a new parser for the provided information
+        /// </summary>
+        public BsonAnonymousTypeParser(BsonObject data) {
+            this._Data = data;
+        }
+
+        #endregion
+
+        #region Fields
+
+        //houses the information to use
+        private BsonObject _Data;
+
+        #endregion
+
+        #region Parsing
+
+        //handles reading a node of anonymous type and
+        //returns the values for the type - This section
+        //is heavily commented to try and explain what it
+        //doing 
+        public object ReadType(string parent, object section) {
+
+            //create a list of values for the constructor
+            List<object> values = new List<object>();
+
+            //and also get this type so we know how to create a
+            //new instance using the constructor
+            Type type = section.GetType();
+
+            //start checking each of the properties
+            foreach (PropertyInfo property in type.GetProperties()) {
+
+                //get the path to the value in the document 
+                //but only if this isn't the first set
+                string path = string.IsNullOrEmpty(parent)
+                    ? property.Name
+                    : string.Concat(parent, ".", property.Name);
+
+                //get the value to use
+                object value = property.GetValue(section, null);
+
+                //if this is anonymous type, parse it
+                if (BsonAnonymousTypeParser.IsAnonymousType(value)) {
+                    value = this.ReadType(path, value);
+                }
+                //if it is not, check to see if there is an existing value
+                else {
+
+                    //try and get the value to use
+                    value = this._Data.Get(path, value);
+                }
+
+                //add this to the list of values
+                values.Add(value);
+
+            }
+
+            //now that our object is created, try and create the instance
+            //but if it fails just give up and return the template value
+            try {
+                return Activator.CreateInstance(type, values.ToArray());
+            }
+            catch {
+                return section;
+            }
+
+        }
+
+        #endregion
+
+        #region Static Methods
+
+        /// <summary>
+        /// Attempts to distingusing anonymous types from
+        /// other object types
+        /// </summary>
+        public static bool IsAnonymousType(object value) {
+
+            //make sure this has a value
+            if (value == null) { return false; }
+
+            //check if this is anonymous type using the name and 
+            //some values that hint it might be anonymous - This
+            //could probably be better though if a better way of
+            //checking for anonymous types becomes available
+            Type type = value.GetType();
+            return Regex.IsMatch(type.FullName, "^(<>f__AnonymousType|VB\\$AnonymousType)") &&
+                type.IsSealed &&
+                type.IsGenericType &&
+                type.BaseType.Equals(typeof(object));
+
+        }
+
+        /// <summary>
+        /// Attempts to assign the values of a BsonObject into new Anonymous Type values
+        /// </summary>
+        public static T PopulateAnonymousType<T>(BsonObject data, T template) {
+            return BsonAnonymousTypeParser.PopulateAnonymousType<T>(data, string.Empty, template);
+        }
+
+        /// <summary>
+        /// Attempts to assign the values of a BsonObject into new Anonymous Type values
+        /// </summary>
+        public static T PopulateAnonymousType<T>(BsonObject data, string parent, T template) {
+            BsonAnonymousTypeParser parser = new BsonAnonymousTypeParser(data);
+            return (T)parser.ReadType(parent, template);
+        }
+
+        #endregion
+
+    }
+
+}

Bson/BsonCollection.cs

@@ -0,0 +1,11 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace CSMongo.Bson {
+
+    public class BsonCollection : BsonObject {
+    }
+
+}

Bson/BsonDocument.cs

@@ -0,0 +1,140 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using CSMongo.IO;
+using System.IO;
+
+namespace CSMongo.Bson {
+    
+    /// <summary>
+    /// Creates a BSON document where the field order is managed
+    /// </summary>
+    public class BsonDocument : BsonObject {
+
+        #region Constants
+
+        private const int DOCUMENT_LENGTH_COUNT = 4;
+        private const int DOCUMENT_TERMINATOR_COUNT = 1;
+
+        #endregion
+
+        #region Constructors
+
+        /// <summary>
+        /// Creates a new empty BSON document
+        /// </summary>
+        public BsonDocument()
+            : base() {
+        }
+
+        /// <summary>
+        /// Creates a new BSON document based on the source provided
+        /// </summary>
+        public BsonDocument(object source)
+            : base(source) {
+        }
+
+        #endregion
+
+        #region Operators
+
+        /// <summary>
+        /// Merges another object with this object - Same as calling Merge
+        /// </summary>
+        public static BsonDocument operator +(BsonDocument target, object value) {
+            target.Merge(value);
+            return target;
+        }
+
+        /// <summary>
+        /// Merges another DynamicObject with this object - Same as calling Merge
+        /// </summary>
+        public static BsonDocument operator +(BsonDocument target, BsonObject value) {
+            target.Merge(value);
+            return target;
+        }
+
+        /// <summary>
+        /// Removes the field provided - Same as calling Remove
+        /// </summary>
+        public static BsonDocument operator -(BsonDocument target, string field) {
+            target.Remove(field);
+            return target;
+        }
+
+        /// <summary>
+        /// Removes the field provided - Same as calling Remove
+        /// </summary>
+        public static BsonDocument operator -(BsonDocument target, string[] fields) {
+            target.Remove(fields);
+            return target;
+        }
+
+        #endregion
+
+        #region Rendering Changes
+
+        /// <summary>
+        /// Renders the bytes required to create a document
+        /// </summary>
+        public override byte[] ToBsonByteArray() {
+
+            //create the default size
+            DynamicStream stream = new DynamicStream(5);
+
+            //generate the bytes
+            stream.InsertAt(4, base.ToBsonByteArray());
+
+            //update the length
+            stream.WriteAt(0, BsonTranslator.AsInt32(stream.Length));
+
+            //and return the bytes to use
+            return stream.ToArray();
+
+        }
+
+        #endregion
+
+        #region Static Creation
+
+        /// <summary>
+        /// Reads an incoming BSON document from a stream
+        /// </summary>
+        public static BsonDocument FromStream(Stream stream) {
+
+            //read the first byte to determine the type
+            BinaryReader reader = new BinaryReader(stream);
+
+            //get the length of this document and the amount
+            //that should be read into the parsing stream.
+            //removes 4 bytes to account for the length value
+            //and an additional 1 byte to account for the
+            //terminator value
+            int length = reader.ReadInt32();
+            int read = length - (DOCUMENT_LENGTH_COUNT + DOCUMENT_TERMINATOR_COUNT);
+
+            //read out the bytes to use and the terminator
+            byte[] bytes = reader.ReadBytes(read);
+            reader.ReadByte();
+
+            //use the bytes to generate the document
+            using (MemoryStream content = new MemoryStream(bytes)) {
+
+                //read the content
+                Dictionary<string, object> values = BsonTranslator.FromStream(content);
+
+                //fill and return the object
+                BsonDocument document = new BsonDocument();
+                document.Merge(values);
+                return document;
+
+            }
+
+        }
+
+        #endregion
+
+    }
+
+}

Bson/BsonFieldDetail.cs

@@ -0,0 +1,55 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using CSMongo.DataTypes;
+
+namespace CSMongo.Bson {
+
+    /// <summary>
+    /// Information about a BSON field after it has
+    /// been rendered into bytes
+    /// </summary>
+    public class BsonFieldDetail {
+
+        #region Constructors
+
+        /// <summary>
+        /// Creates a new set of details for a BSON field
+        /// </summary>
+        public BsonFieldDetail(string field, byte[] bytes, MongoDataType type) {
+            this.Field = field;
+            this.Bytes = bytes;
+            this.Type = type;
+        }
+
+        #endregion
+
+        #region Properties
+
+        /// <summary>
+        /// The string name for this field
+        /// </summary>
+        public string Field { get; private set; }
+
+        /// <summary>
+        /// The original MongoDataType for this field
+        /// </summary>
+        public MongoDataType Type { get; private set; }
+
+        /// <summary>
+        /// The bytes that create this object
+        /// </summary>
+        public byte[] Bytes { get; private set; }
+
+        /// <summary>
+        /// Returns the total length of the bytes in the set
+        /// </summary>
+        public int Length {
+            get { return this.Bytes is byte[] ? this.Bytes.Length : 0; }
+        }
+
+        #endregion
+
+    }
+}

Bson/BsonMongoDictionary.cs

@@ -0,0 +1,15 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using CSMongo.DataTypes;
+
+namespace CSMongo.Bson {
+
+    /// <summary>
+    /// General container for holding Mongo fields in a document
+    /// </summary>
+    public class BsonMongoDictionary : Dictionary<string, MongoDataType> {
+    }
+
+}

Bson/BsonMongoFieldReference.cs

@@ -0,0 +1,32 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using CSMongo.Bson;
+using CSMongo.DataTypes;
+
+namespace CSMongo.Bson {
+
+    /// <summary>
+    /// Details about a MongoDataType and the location
+    /// </summary>
+    public class MongoFieldReference {
+
+        /// <summary>
+        /// The parent object for this field
+        /// </summary>
+        public BsonObject Parent { get; set; }
+
+        /// <summary>
+        /// The name of the field that holds this value
+        /// </summary>
+        public string Name { get; set; }
+
+        /// <summary>
+        /// The actual field controller for this type
+        /// </summary>
+        public MongoDataType Field { get; set; }
+    
+    }
+
+}