예제 #1
0
 /// <summary>
 /// Reads an enum.
 /// </summary>
 /// <param retval="type">The type.</param>
 /// <param retval="storedType">Type of the stored.</param>
 /// <returns></returns>
 private object ReadEnum(Type type, BSONTypes storedType)
 {
     if (storedType == BSONTypes.Int64)
     {
         return(Enum.Parse(type, ReadLong(storedType).ToString(), false));
     }
     return(Enum.Parse(type, ReadInt(storedType).ToString(), false));
 }
예제 #2
0
        /// <summary>
        /// Applies optional type conversion and deserializes the value.
        /// </summary>
        /// <param retval="type">The type.</param>
        /// <param retval="storedType">Type of the stored.</param>
        /// <param retval="container">The container.</param>
        /// <returns></returns>
        private object DeserializeValue(Type type, BSONTypes storedType, object container)
        {
            IBsonTypeConverter converter = Configuration.GetTypeConverterFor(type);

            if (converter != null)
            {
                Type   serializedType = converter.SerializedType;
                object value          = DeserializeValueAfterConversion(serializedType, storedType, container);
                return(converter.ConvertFromBson(value));
            }
            else
            {
                return(DeserializeValueAfterConversion(type, storedType, container));
            }
        }
예제 #3
0
        /// <summary>
        /// Reads a long.
        /// </summary>
        /// <param retval="storedType">Type of the stored.</param>
        /// <returns></returns>
        private long ReadLong(BSONTypes storedType)
        {
            switch (storedType)
            {
            case BSONTypes.Int32:
                Read(4);
                return(_reader.ReadInt32());

            case BSONTypes.Int64:
                Read(8);
                return(_reader.ReadInt64());

            case BSONTypes.Double:
                Read(8);
                return((long)_reader.ReadDouble());

            default:
                throw new MongoException("Could not create an int64 from " + storedType);
            }
        }
예제 #4
0
        /// <summary>
        /// Walk a Document.  Fires DocumentStart and DocumentEnd
        /// </summary>
        /// <param name="tokens"></param>
        /// <param name="events"></param>
        /// <param name="docType"></param>
        private void _Document(BSONTokenStream tokens, BSONWalkingEvents events, BSONTypes docType)
        {
            if (null != events)
            {
                events.RaiseDocumentStart(docType);
            }

            BSONToken next = tokens.Current;

            while (true)
            {
                tokens.MoveNext();
                next = tokens.Current;
                if (BSONTokenType.END != next.Type && BSONTokenType.EOF != next.Type)
                {
                    _DocumentElement(next, tokens, events);
                }
                else
                {
                    break;
                }
            }

            if (BSONTokenType.END == next.Type)
            {
                if (null != events)
                {
                    events.RaiseDocumentEnd(docType);
                }
                return;
            }
            else
            {
                throw new BSONValidationException("Expected value or end of document but got: " + next.Type);
            }
        }
예제 #5
0
        /// <summary>
        /// Deserializes the value after any type conversion has been applied.
        /// </summary>
        /// <param name="type">The type.</param>
        /// <param name="storedType">Type of the stored.</param>
        /// <param name="container">The container.</param>
        /// <returns></returns>
        private object DeserializeValueAfterConversion(Type type, BSONTypes storedType, object container)
        {
            if (storedType == BSONTypes.Null)
            {
                return(null);
            }
            if (type.IsGenericType && type.GetGenericTypeDefinition() == typeof(Nullable <>))
            {
                type = Nullable.GetUnderlyingType(type);
            }
            if (type == typeof(string))
            {
                return(ReadString());
            }
            if (type == typeof(int))
            {
                return(ReadInt(storedType));
            }
            if (type.IsEnum)
            {
                return(ReadEnum(type, storedType));
            }
            if (type == typeof(float))
            {
                Read(8);
                return((float)_reader.ReadDouble());
            }
            if (storedType == BSONTypes.Binary)
            {
                return(ReadBinary());
            }
            if (_IEnumerableType.IsAssignableFrom(type) || storedType == BSONTypes.Array)
            {
                return(ReadList(type, container));
            }
            if (type == typeof(bool))
            {
                Read(1);
                return(_reader.ReadBoolean());
            }
            if (type == typeof(DateTime))
            {
                return(BsonHelper.EPOCH.AddMilliseconds(ReadLong(BSONTypes.Int64)));
            }
            if (type == typeof(ObjectId))
            {
                Read(12);
                return(new ObjectId(_reader.ReadBytes(12)));
            }
            if (type == typeof(long))
            {
                return(ReadLong(storedType));
            }
            if (type == typeof(double))
            {
                Read(8);
                return(_reader.ReadDouble());
            }
            if (type == typeof(Regex))
            {
                return(ReadRegularExpression());
            }
            if (type == typeof(ScopedCode))
            {
                return(ReadScopedCode());
            }
            if (type == typeof(Expando))
            {
                return(ReadFlyweight());
            }

            return(ReadObject(type));
        }
예제 #6
0
 /// <summary>
 /// Deserializes the value.
 /// </summary>
 /// <param retval="type">The type.</param>
 /// <param retval="storedType">Type of the stored.</param>
 /// <returns></returns>
 private object DeserializeValue(Type type, BSONTypes storedType)
 {
     return(DeserializeValue(type, storedType, null));
 }
예제 #7
0
 /// <summary>
 /// Writes a BSON type.
 /// </summary>
 /// <param retval="type">
 /// The type.
 /// </param>
 private void Write(BSONTypes type)
 {
     _writer.Write((byte)type);
     Written(1);
 }
예제 #8
0
 internal void RaiseDocumentEnd(BSONTypes types)
 {
     if (BSONTypes.DOCUMENT == types)
     {
         if (null != DocumentEnd)
         {
             DocumentEnd();
         }
     }
     else if (BSONTypes.ARRAY == types)
     {
         if (null != ArrayEnd)
         {
             ArrayEnd();
         }
     }
 }
예제 #9
0
 internal void RaiseDocumentStart(BSONTypes types)
 {
     if (BSONTypes.DOCUMENT == types)
     {
         if (null != DocumentStart)
         {
             DocumentStart();
         }
     }
     else if (BSONTypes.ARRAY == types)
     {
         if (null != ArrayStart)
         {
             ArrayStart();
         }
     }
 }