/// <summary>
/// Initializes a new instance of the DateTimeSerializationOptions class.
/// </summary>
/// <param name="kind">The DateTimeKind (Local, Unspecified or Utc).</param>
/// <param name="representation">The external representation.</param>
public DateTimeSerializationOptions(
DateTimeKind kind,
BsonType representation
) {
this.kind = kind;
this.representation = representation;
}
public CollectionProperty(string name, BsonType type, string fullName)
{
_name = name;
_type = type;
_fullName = fullName;
Children = new Dictionary<string, CollectionProperty>();
}
/// <summary>
/// Initializes a new instance of the DateTimeSerializationOptions class.
/// </summary>
/// <param name="dateOnly">Whether this DateTime consists of a Date only.</param>
/// <param name="representation">The external representation.</param>
public DateTimeSerializationOptions(
bool dateOnly,
BsonType representation
) {
this.dateOnly = dateOnly;
this.representation = representation;
}
public int CalculateSize(BsonType t_Type, List<object> value)
{
switch (t_Type)
{
case BsonType.Object:
{
foreach (var p in value)
{
//Console.WriteLine(new { p });
Native.document.body += new IHTMLPre { new { p } };
}
return -1;
}
case BsonType.Integer:
return 4;
case BsonType.Long:
return 8;
case BsonType.Number:
return 8;
case BsonType.Boolean:
return 1;
case BsonType.Null:
case BsonType.Undefined:
return 0;
case BsonType.Date:
return 8;
default:
return 12;
}
}
public static IBehavior Find(BsonType bsonType)
{
IBehavior behavior;
return DsonBehaviors.TryGetValue(bsonType, out behavior)
? behavior
: null;
}
// constructors
internal JsonReaderBookmark(BsonReaderState state, BsonType currentBsonType, string currentName, JsonReaderContext context, JsonToken currentToken, BsonValue currentValue, JsonToken pushedToken, int position)
: base(state, currentBsonType, currentName)
{
_context = context.Clone();
_currentToken = currentToken;
_currentValue = currentValue;
_pushedToken = pushedToken;
_position = position;
}
/// <summary>
/// Initializes a new instance of the RepresentationSerializationOptions class.
/// </summary>
/// <param name="representation">The external representation.</param>
/// <param name="allowOverflow">Whether to allow overflow.</param>
/// <param name="allowTruncation">Whether to allow truncation.</param>
public RepresentationSerializationOptions(
BsonType representation,
bool allowOverflow,
bool allowTruncation
) {
this.representation = representation;
this.allowOverflow = allowOverflow;
this.allowTruncation = allowTruncation;
}
internal BsonDocumentReaderBookmark(
BsonDocumentReaderContext context,
BsonReadState state,
BsonType currentBsonType
)
{
this.context = context.Clone();
this.state = state;
this.currentBsonType = currentBsonType;
}
protected BsonReaderBookmark(
BsonReadState state,
BsonType currentBsonType,
string currentName
)
{
this.state = state;
this.currentBsonType = currentBsonType;
this.currentName = currentName;
}
public void ReturnToBookmark(PBBsonReaderBookmark bookmark)
{
_reader.ReturnToBookmark(bookmark.Bookmark);
_type = bookmark.Type;
_name = bookmark.Name;
_bsonType = bookmark.BsonType;
_value = bookmark.Value;
_indent = bookmark.Indent;
_indentString = bookmark.IndentString;
}
public int Read(BsonReader reader)
{
sbyte typeNum = (sbyte)reader.ReadByte();
int bytesRead;
this.Name = reader.ReadString();
this.Val = BsonConvert.Create((BsonDataType)typeNum);
bytesRead = this.Val.Read(reader);
bytesRead += (1 + this.Name.Length + 1); //type byte & name + term
return bytesRead;
}
public BsonBinaryReader(
BsonBuffer buffer,
BsonBinaryReaderSettings settings
) {
this.buffer = buffer ?? new BsonBuffer();
this.disposeBuffer = buffer == null; // only call Dispose if we allocated the buffer
this.settings = settings;
context = null;
state = BsonReadState.Initial;
currentBsonType = BsonType.Document;
}
// constructors
/// <summary>
/// Initializes a new instance of the <see cref="EnumRepresentationConvention" /> class.
/// </summary>
/// <param name="representation">The serialization representation. 0 is used to detect representation
/// from the enum itself.</param>
public EnumRepresentationConvention(BsonType representation)
{
if (!((representation == 0) ||
(representation == BsonType.String) ||
(representation == BsonType.Int32) ||
(representation == BsonType.Int64)))
{
throw new ArgumentException("Enums can only be represented as String, Int32, Int64 or the type of the enum");
}
_representation = representation;
}
// constructors
internal BsonBinaryReaderBookmark(
BsonReaderState state,
BsonType currentBsonType,
string currentName,
BsonBinaryReaderContext context,
int position)
: base(state, currentBsonType, currentName)
{
_context = context.Clone();
_position = position;
}
public void TestConvention(BsonType value)
{
var convention = new EnumRepresentationConvention(value);
var classMap = new BsonClassMap<TestClass>();
var nonEnumMemberMap = classMap.MapMember(x => x.NonEnum);
var defaultEnumMemberMap = classMap.MapMember(x => x.DefaultEnum);
var changedEnumMemberMap = classMap.MapMember(x => x.ChangedRepresentationEnum);
convention.Apply(nonEnumMemberMap);
convention.Apply(changedEnumMemberMap);
Assert.AreEqual(value, ((IRepresentationConfigurable)(changedEnumMemberMap.GetSerializer())).Representation);
}
// constructors
internal BsonDocumentReaderBookmark(
BsonReaderState state,
BsonType currentBsonType,
string currentName,
BsonDocumentReaderContext context,
BsonValue currentValue)
: base(state, currentBsonType, currentName)
{
_context = context.Clone();
_currentValue = currentValue;
}
internal BsonBinaryReaderBookmark(
BsonBinaryReaderContext context,
BsonReadState state,
BsonType currentBsonType,
int position
)
{
this.context = context;
this.state = state;
this.currentBsonType = currentBsonType;
this.position = position;
}
public void TestConvention(BsonType value)
{
var convention = new EnumRepresentationConvention(value);
var classMap = new BsonClassMap<TestClass>();
var nonEnumMemberMap = classMap.MapMember(x => x.NonEnum);
var defaultEnumMemberMap = classMap.MapMember(x => x.DefaultEnum);
var changedEnumMemberMap = classMap.MapMember(x => x.ChangedRepresentationEnum);
convention.Apply(nonEnumMemberMap);
convention.Apply(changedEnumMemberMap);
Assert.IsNull(nonEnumMemberMap.SerializationOptions);
Assert.IsNull(defaultEnumMemberMap.SerializationOptions);
Assert.AreEqual(value, ((RepresentationSerializationOptions)changedEnumMemberMap.SerializationOptions).Representation);
}
public int CalculateSize(BsonType t_Type, List<object> value)
{
//TestSwitchForEach.BsonBinaryWriter <0000> nop
//TestSwitchForEach.BsonBinaryWriter <004a> nop
//TestSwitchForEach.BsonBinaryWriter <0053> br.s, to be optimized away
//enter finally { mname = <0053> br.s, to be optimized away.try }
//TestSwitchForEach.BsonBinaryWriter <006b> ldloca.s
//enter finally { mname = <006b> ldloca.s.try }
//TestSwitchForEach.BsonBinaryWriter <0055> ldloca.s
//{ p = { x = 1 } }
//enter finally { mname = <0055> ldloca.s.try }
//TestSwitchForEach.BsonBinaryWriter <006b> ldloca.s
//enter finally { mname = <006b> ldloca.s.try }
//TestSwitchForEach.BsonBinaryWriter <0055> ldloca.s
//{ p = { x = 2 } }
//enter finally { mname = <0055> ldloca.s.try }
//TestSwitchForEach.BsonBinaryWriter <006b> ldloca.s
//enter finally { mname = <006b> ldloca.s.try }
//TestSwitchForEach.BsonBinaryWriter <0078> leave.s, to be optimized away
//enter finally { mname = <0078> leave.s, to be optimized away.try }
//TestSwitchForEach.BsonBinaryWriter <0089> nop
//TestSwitchForEach.BsonBinaryWriter <00ab> ldloc.1
switch (t_Type)
{
case BsonType.Object:
{
foreach (var p in value)
{
Console.WriteLine(new { p });
}
return -1;
}
case BsonType.Integer:
return 4;
case BsonType.Long:
return 8;
case BsonType.Number:
return 8;
case BsonType.Boolean:
return 1;
case BsonType.Null:
case BsonType.Undefined:
return 0;
case BsonType.Date:
return 8;
default:
return 12;
}
}
// https://sites.google.com/a/jsc-solutions.net/backlog/knowledge-base/2014/201405/20140524
//public static int WriteEscapedJavaScriptString(BsonType t_Type, ref char[] writeBuffer)
//public static int WriteEscapedJavaScriptString(BsonType t_Type, char[] writeBuffer)
public int WriteEscapedJavaScriptString(
BsonType t_Type,
char[] writeBuffer,
// why is this not made byref?
foo foo)
{
foo foocopy = foo;
// X:\jsc.svn\examples\rewrite\Test\TestSwitchForEach\TestSwitchForEach\Program.cs
switch (t_Type)
{
case BsonType.Object:
{
//foreach (var p in writeBuffer)
foreach (var p in foo.writeBuffer)
{
Console.WriteLine(new { p });
}
return -1;
}
case BsonType.Integer:
return 4;
case BsonType.Long:
return 8;
case BsonType.Number:
return 8;
case BsonType.Boolean:
return 1;
case BsonType.Null:
case BsonType.Undefined:
return 0;
case BsonType.Date:
return 8;
default:
return 12;
}
}
private void ReadType(BsonType type)
{
switch (type)
{
case BsonType.Number:
var d = ReadDouble();
if (_floatParseHandling == FloatParseHandling.Decimal)
{
SetToken(JsonToken.Float, Convert.ToDecimal(d, CultureInfo.InvariantCulture));
}
else
{
SetToken(JsonToken.Float, d);
}
break;
case BsonType.String:
case BsonType.Symbol:
SetToken(JsonToken.String, ReadLengthString());
break;
case BsonType.Object:
{
SetToken(JsonToken.StartObject);
var newContext = new ContainerContext(BsonType.Object);
PushContext(newContext);
newContext.Length = ReadInt32();
break;
}
case BsonType.Array:
{
SetToken(JsonToken.StartArray);
var newContext = new ContainerContext(BsonType.Array);
PushContext(newContext);
newContext.Length = ReadInt32();
break;
}
case BsonType.Binary:
BsonBinaryType binaryType;
var data = ReadBinary(out binaryType);
var value = binaryType != BsonBinaryType.Uuid
? data
: (object)new Guid(data);
SetToken(JsonToken.Bytes, value);
break;
case BsonType.Undefined:
SetToken(JsonToken.Undefined);
break;
case BsonType.Oid:
var oid = ReadBytes(12);
SetToken(JsonToken.Bytes, oid);
break;
case BsonType.Boolean:
var b = Convert.ToBoolean(ReadByte());
SetToken(JsonToken.Boolean, b);
break;
case BsonType.Date:
var ticks = ReadInt64();
var utcDateTime = DateTimeUtils.ConvertJavaScriptTicksToDateTime(ticks);
DateTime dateTime;
switch (DateTimeKindHandling)
{
case DateTimeKind.Unspecified:
dateTime = DateTime.SpecifyKind(utcDateTime, DateTimeKind.Unspecified);
break;
case DateTimeKind.Local:
dateTime = utcDateTime.ToLocalTime();
break;
default:
dateTime = utcDateTime;
break;
}
SetToken(JsonToken.Date, dateTime);
break;
case BsonType.Null:
SetToken(JsonToken.Null);
break;
case BsonType.Regex:
var expression = ReadString();
var modifiers = ReadString();
var regex = @"/" + expression + @"/" + modifiers;
SetToken(JsonToken.String, regex);
break;
case BsonType.Reference:
SetToken(JsonToken.StartObject);
_bsonReaderState = BsonReaderState.ReferenceStart;
break;
case BsonType.Code:
SetToken(JsonToken.String, ReadLengthString());
break;
case BsonType.CodeWScope:
SetToken(JsonToken.StartObject);
_bsonReaderState = BsonReaderState.CodeWScopeStart;
break;
case BsonType.Integer:
SetToken(JsonToken.Integer, (long)ReadInt32());
break;
case BsonType.TimeStamp:
case BsonType.Long:
SetToken(JsonToken.Integer, ReadInt64());
break;
default:
throw new ArgumentOutOfRangeException(nameof(type), "Unexpected BsonType value: " + type);
}
}
private void AddValue(object value, BsonType type)
{
AddToken(new BsonValue(value, type));
}
/// <summary>
/// Initializes a new instance of the <see cref="DoubleSerializer"/> class.
/// </summary>
/// <param name="representation">The representation.</param>
public DoubleSerializer(BsonType representation)
: this(representation, new RepresentationConverter(false, false))
{
}
// constructors
/// <summary>
/// Initializes a new instance of the BsonReaderBookmark class.
/// </summary>
/// <param name="state">The state of the reader.</param>
/// <param name="currentBsonType">The current BSON type.</param>
/// <param name="currentName">The name of the current element.</param>
protected BsonReaderBookmark(BsonReaderState state, BsonType currentBsonType, string currentName)
{
_state = state;
_currentBsonType = currentBsonType;
_currentName = currentName;
}
private void ReadType(BsonType type)
{
switch (type)
{
case BsonType.Number:
SetToken(JsonToken.Float, ReadDouble());
break;
case BsonType.String:
case BsonType.Symbol:
SetToken(JsonToken.String, ReadLengthString());
break;
case BsonType.Object:
{
SetToken(JsonToken.StartObject);
ContainerContext newContext = new ContainerContext(BsonType.Object);
PushContext(newContext);
newContext.Length = ReadInt32();
break;
}
case BsonType.Array:
{
SetToken(JsonToken.StartArray);
ContainerContext newContext = new ContainerContext(BsonType.Array);
PushContext(newContext);
newContext.Length = ReadInt32();
break;
}
case BsonType.Binary:
SetToken(JsonToken.Bytes, ReadBinary());
break;
case BsonType.Undefined:
SetToken(JsonToken.Undefined);
break;
case BsonType.Oid:
byte[] oid = ReadBytes(12);
SetToken(JsonToken.Bytes, oid);
break;
case BsonType.Boolean:
bool b = Convert.ToBoolean(ReadByte());
SetToken(JsonToken.Boolean, b);
break;
case BsonType.Date:
long ticks = ReadInt64();
DateTime utcDateTime = JsonConvert.ConvertJavaScriptTicksToDateTime(ticks);
DateTime dateTime;
switch (DateTimeKindHandling)
{
case DateTimeKind.Unspecified:
dateTime = DateTime.SpecifyKind(utcDateTime, DateTimeKind.Unspecified);
break;
case DateTimeKind.Local:
dateTime = utcDateTime.ToLocalTime();
break;
default:
dateTime = utcDateTime;
break;
}
SetToken(JsonToken.Date, dateTime);
break;
case BsonType.Null:
SetToken(JsonToken.Null);
break;
case BsonType.Regex:
string expression = ReadString();
string modifiers = ReadString();
string regex = @"/" + expression + @"/" + modifiers;
SetToken(JsonToken.String, regex);
break;
case BsonType.Reference:
SetToken(JsonToken.StartObject);
_bsonReaderState = BsonReaderState.ReferenceStart;
break;
case BsonType.Code:
SetToken(JsonToken.String, ReadLengthString());
break;
case BsonType.CodeWScope:
SetToken(JsonToken.StartObject);
_bsonReaderState = BsonReaderState.CodeWScopeStart;
break;
case BsonType.Integer:
SetToken(JsonToken.Integer, (long)ReadInt32());
break;
case BsonType.TimeStamp:
case BsonType.Long:
SetToken(JsonToken.Integer, ReadInt64());
break;
default:
throw new ArgumentOutOfRangeException("type", "Unexpected BsonType value: " + type);
}
}
private BsonEmpty(BsonType type)
{
Type = type;
}
/***************************************************/
private object DeserializeDiscriminatedValue(BsonDeserializationContext context, BsonDeserializationArgs args)
{
// First try to recover the object type
IBsonReader reader = context.Reader;
BsonReaderBookmark bookmark = reader.GetBookmark();
Type actualType = typeof(CustomObject);
try
{
actualType = _discriminatorConvention.GetActualType(reader, typeof(object));
}
catch
{
// This is were we can call the Version_Engine to return the new type string from the old one if exists
string recordedType = GetCurrentTypeValue(reader);
// If failed, return Custom object
context.Reader.ReturnToBookmark(bookmark);
Engine.Reflection.Compute.RecordWarning("The type " + recordedType + " is unknown -> data returned as custom objects.");
IBsonSerializer customSerializer = BsonSerializer.LookupSerializer(typeof(CustomObject));
return(customSerializer.Deserialize(context, args));
}
// Handle the special case where the type is object
if (actualType == typeof(object))
{
BsonType currentBsonType = reader.GetCurrentBsonType();
if (currentBsonType == BsonType.Document && context.DynamicDocumentSerializer != null)
{
return(context.DynamicDocumentSerializer.Deserialize(context, args));
}
reader.ReadStartDocument();
reader.ReadEndDocument();
return(new object());
}
// Handle the genral case of finding the correct deserialiser and calling it
IBsonSerializer bsonSerializer = BsonSerializer.LookupSerializer(actualType);
IBsonPolymorphicSerializer bsonPolymorphicSerializer = bsonSerializer as IBsonPolymorphicSerializer;
if (bsonPolymorphicSerializer != null && bsonPolymorphicSerializer.IsDiscriminatorCompatibleWithObjectSerializer)
{
bookmark = context.Reader.GetBookmark();
try
{
return(bsonSerializer.Deserialize(context, args));
}
catch
{
context.Reader.ReturnToBookmark(bookmark);
Engine.Reflection.Compute.RecordWarning("Cannot find a definition of type " + actualType.FullName + " that matches the object to deserialise -> data returned as custom objects.");
IBsonSerializer customSerializer = BsonSerializer.LookupSerializer(typeof(CustomObject));
CustomObject fallback = customSerializer.Deserialize(context, args) as CustomObject;
//This is where we will try to get the correct object type from the custom object using the versionning engine
// If failed, just return the custom object
return(fallback);
}
}
object result = null;
bool flag = false;
reader.ReadStartDocument();
while (reader.ReadBsonType() != 0)
{
string text = reader.ReadName();
if (text == _discriminatorConvention.ElementName)
{
reader.SkipValue();
}
else
{
if (!(text == "_v"))
{
throw new FormatException($"Unexpected element name: '{text}'.");
}
result = bsonSerializer.Deserialize(context);
flag = true;
}
}
reader.ReadEndDocument();
if (!flag)
{
throw new FormatException("_v element missing.");
}
return(result);
}
/// <summary>
/// Initializes a new instance of the <see cref="TypeRepresentationSerializationOptionsConvention"/> class.
/// </summary>
/// <param name="type">The type of the member.</param>
/// <param name="representation">The BSON representation to use for this type.</param>
public TypeRepresentationSerializationOptionsConvention(Type type, BsonType representation)
{
_type = type;
_representation = representation;
}
/// <summary>
/// Initializes a new instance of the RepresentationSerializationOptions class.
/// </summary>
/// <param name="representation">The external representation.</param>
public RepresentationSerializationOptions(
BsonType representation
)
{
this.representation = representation;
}
public void RemoveFilesFromUserAccounts(File file, string username)
{
UserAccount account = GetUser(username);
IMongoCollection <BsonDocument> userCollection = GetCollection(USER_COLLECTION);
FilterDefinition <BsonDocument> getUserFilter = Builders <BsonDocument> .Filter.Eq("_id", username);
BsonDocument user = userCollection.Find(getUserFilter).First();
BsonType typeOfFiles = user["ListOfFiles"].BsonType;
List <File> listOfFiles = new List <File>();
if (typeOfFiles != BsonType.Null)
{
var userFilesList = user["ListOfFiles"].AsBsonArray;
foreach (var element in userFilesList)
{
File f = null;
f = BsonSerializer.Deserialize <File>(element.ToJson());
if (f.GUID != file.GUID)
{
listOfFiles.Add(f);
}
}
}
UserAccount updatedAccount = GetUser(username);
userCollection.DeleteOne(updatedAccount.ToBsonDocument());
updatedAccount.ListOfFiles = listOfFiles;
userCollection.InsertOne(updatedAccount.ToBsonDocument());
Dictionary <string, Permission> users = new Dictionary <string, Permission>();
IMongoCollection <BsonDocument> fileCollection = GetCollection(FILE_COLLECTION);
FilterDefinition <BsonDocument> deleteFileFilter = Builders <BsonDocument> .Filter.Eq("GUID", file.GUID);
BsonDocument fileToUpdateUsers = fileCollection.Find(deleteFileFilter).First();
File sharingFile = BsonSerializer.Deserialize <File>(file.ToJson());
file.Users = sharingFile.Users;
Dictionary <string, Permission> remainingUsers = new Dictionary <string, Permission>();
String toBeRemovedUsername = null;
foreach (KeyValuePair <string, Permission> entry in sharingFile.Users)
{
string currentAccount = entry.Key;
Permission currentPermission = entry.Value;
if (currentAccount.Equals(username))
{
toBeRemovedUsername = currentAccount;
}
else
{
remainingUsers.Add(currentAccount, currentPermission);
}
}
RemoveUserFromAccountFileUsers(toBeRemovedUsername, file.GUID, remainingUsers);
DeleteFileFromFileCollection(sharingFile.GUID);
sharingFile.Users = remainingUsers;
fileCollection.InsertOne(sharingFile.ToBsonDocument());
}
public BsonValue(object value, BsonType type)
{
this._value = value;
this._type = type;
}
/// <summary>
/// Internal implementation of insert a document
/// </summary>
private void InsertDocument(CollectionPage col, BsonDocument doc, BsonType autoId)
{
BsonValue id;
// collection Sequence was created after release current datafile version.
// In this case, Sequence will be 0 but already has documents. Let's fix this
// ** this code can be removed when datafile change from 7 (HeaderPage.FILE_VERSION) **
if (col.Sequence == 0 && col.DocumentCount > 0)
{
var max = this.Max(col.CollectionName, "_id");
// if max value is a number, convert to Sequence last value
// if not, just set sequence as document count
col.Sequence = (max.IsInt32 || max.IsInt64 || max.IsDouble || max.IsDecimal) ?
Convert.ToInt64(max.RawValue) :
Convert.ToInt64(col.DocumentCount);
}
// increase collection sequence _id
col.Sequence++;
_pager.SetDirty(col);
// if no _id, add one
if (!doc.RawValue.TryGetValue("_id", out id))
{
doc["_id"] = id =
autoId == BsonType.ObjectId ? new BsonValue(ObjectId.NewObjectId()) :
autoId == BsonType.Guid ? new BsonValue(Guid.NewGuid()) :
autoId == BsonType.DateTime ? new BsonValue(DateTime.Now) :
autoId == BsonType.Int32 ? new BsonValue((Int32)col.Sequence) :
autoId == BsonType.Int64 ? new BsonValue(col.Sequence) : BsonValue.Null;
}
// create bubble in sequence number if _id is bigger than current sequence
else if (autoId == BsonType.Int32 || autoId == BsonType.Int64)
{
var current = id.AsInt64;
// if current id is bigger than sequence, jump sequence to this number. Other was, do not increse sequnce
col.Sequence = current >= col.Sequence ? current : col.Sequence - 1;
}
// test if _id is a valid type
if (id.IsNull || id.IsMinValue || id.IsMaxValue)
{
throw LiteException.InvalidDataType("_id", id);
}
_log.Write(Logger.COMMAND, "insert document on '{0}' :: _id = {1}", col.CollectionName, id.RawValue);
// serialize object
var bytes = BsonSerializer.Serialize(doc);
// storage in data pages - returns dataBlock address
var dataBlock = _data.Insert(col, bytes);
// store id in a PK index [0 array]
var pk = _indexer.AddNode(col.PK, id, null);
// do link between index <-> data block
pk.DataBlock = dataBlock.Position;
// for each index, insert new IndexNode
foreach (var index in col.GetIndexes(false))
{
// for each index, get all keys (support now multi-key) - gets distinct values only
// if index are unique, get single key only
var expr = new BsonExpression(index.Expression);
var keys = expr.Execute(doc, true);
// do a loop with all keys (multi-key supported)
foreach (var key in keys)
{
// insert node
var node = _indexer.AddNode(index, key, pk);
// link my index node to data block address
node.DataBlock = dataBlock.Position;
}
}
}
/// <summary>
/// Bulk documents to a collection - use data chunks for most efficient insert
/// </summary>
public int InsertBulk(string collection, IEnumerable <BsonDocument> docs, int batchSize = 5000, BsonType autoId = BsonType.ObjectId)
{
if (collection.IsNullOrWhiteSpace())
{
throw new ArgumentNullException("collection");
}
if (docs == null)
{
throw new ArgumentNullException("docs");
}
if (batchSize < 100 || batchSize > 100000)
{
throw new ArgumentException("batchSize must be a value between 100 and 100000");
}
var count = 0;
foreach (var batch in docs.Batch(batchSize))
{
count += this.Insert(collection, batch, autoId);
}
return(count);
}
public ContainerContext(BsonType type) => Type = type;
public BsonValue(object value, BsonType type)
{
_value = value;
_type = type;
}
public Mapping(Type netType, BsonType bsonType)
{
this.netType = netType;
this.bsonType = bsonType;
}
// explicit interface implementations
IBsonSerializer IRepresentationConfigurable.WithRepresentation(BsonType representation)
{
return(WithRepresentation(representation));
}
public void constructor_should_initialize_instance_when_representation_is_valid(BsonType representation)
{
var subject = new EnumRepresentationConvention(representation);
subject.Representation.Should().Be(representation);
}
public AstTypeFilterOperation(BsonType type)
{
_types = new List <BsonType> {
type
}.AsReadOnly();
}
/// <summary>
/// Maps an object to a specific BsonValue type.
/// </summary>
/// <param name="value">An object.</param>
/// <param name="bsonType">The BsonType to map to.</param>
/// <returns>A BsonValue.</returns>
public static BsonValue MapToBsonValue(object value, BsonType bsonType)
{
if (value == null)
{
throw new ArgumentNullException("value");
}
var valueType = value.GetType();
if (valueType.IsEnum)
{
valueType = Enum.GetUnderlyingType(valueType);
switch (Type.GetTypeCode(valueType))
{
case TypeCode.Byte: value = (int)(byte)value; break;
case TypeCode.Int16: value = (int)(short)value; break;
case TypeCode.Int32: value = (int)value; break;
case TypeCode.Int64: value = (long)value; break;
case TypeCode.SByte: value = (int)(sbyte)value; break;
case TypeCode.UInt16: value = (int)(ushort)value; break;
case TypeCode.UInt32: value = (long)(uint)value; break;
case TypeCode.UInt64: value = (long)(ulong)value; break;
}
valueType = value.GetType();
}
Conversion conversion; // the conversion (if it exists) that will convert value to bsonType
if (fromToMappings.TryGetValue(Mapping.FromTo(valueType, bsonType), out conversion))
{
return(Convert(value, conversion));
}
// these coercions can't be handled by the conversions table (because of the interfaces)
switch (bsonType)
{
case BsonType.Array:
if (value is IEnumerable)
{
return(new BsonArray((IEnumerable)value));
}
break;
case BsonType.Document:
if (value is IDictionary <string, object> )
{
return(new BsonDocument((IDictionary <string, object>)value));
}
if (value is IDictionary)
{
return(new BsonDocument((IDictionary)value));
}
break;
}
string message = string.Format(".NET type {0} cannot be mapped to BsonType.{1}.", value.GetType().FullName, bsonType);
throw new ArgumentException(message, "value");
}
private BsonEmpty(BsonType type)
{
this.Type = type;
}
// constructors
/// <summary>
/// Initializes a new instance of the TimeSpanSerializationOptions class.
/// </summary>
/// <param name="representation">The representation for serialized TimeSpans.</param>
public TimeSpanSerializationOptions(BsonType representation)
: this(representation, TimeSpanUnits.Ticks)
{
}
// constructors
/// <summary>
/// Initializes a new instance of the RepresentationSerializationOptions class.
/// </summary>
/// <param name="representation">The external representation.</param>
public RepresentationSerializationOptions(BsonType representation)
{
_representation = representation;
}
private void AddValue(object value, BsonType type)
{
AddToken(new BsonValue(value, type));
}
/***************************************************/
private object DeserializeDiscriminatedValue(BsonDeserializationContext context, BsonDeserializationArgs args)
{
// First try to recover the object type
IBsonReader reader = context.Reader;
BsonReaderBookmark bookmark = reader.GetBookmark();
Type actualType = typeof(CustomObject);
try
{
actualType = _discriminatorConvention.GetActualType(reader, typeof(object));
}
catch
{
try
{
context.Reader.ReturnToBookmark(bookmark);
DeprecatedSerializer deprecatedSerialiser = new DeprecatedSerializer();
return(deprecatedSerialiser.Deserialize(context, args));
}
catch { }
}
context.Reader.ReturnToBookmark(bookmark);
if (actualType == null)
{
return(null);
}
// Handle the special case where the type is object
if (actualType == typeof(object))
{
BsonType currentBsonType = reader.GetCurrentBsonType();
if (currentBsonType == BsonType.Document && context.DynamicDocumentSerializer != null)
{
return(context.DynamicDocumentSerializer.Deserialize(context, args));
}
reader.ReadStartDocument();
reader.ReadEndDocument();
return(new object());
}
// Handle the general case of finding the correct deserialiser and calling it
try
{
if (!BsonClassMap.IsClassMapRegistered(actualType))
{
Compute.RegisterClassMap(actualType); // LookupSerializer creates the classMap if it doesn't exist so important to do it through our own method
}
IBsonSerializer bsonSerializer = BsonSerializer.LookupSerializer(actualType);
if (bsonSerializer.GetType().Name == "EnumerableInterfaceImplementerSerializer`2" && context.Reader.CurrentBsonType == BsonType.Document)
{
if (!m_FallbackSerialisers.ContainsKey(actualType))
{
CreateFallbackSerialiser(actualType);
}
bsonSerializer = m_FallbackSerialisers[actualType];
}
else if (actualType.Name == "Dictionary`2" && context.Reader.CurrentBsonType == BsonType.Document)
{
DictionarySerializer dicSerialiser = new DictionarySerializer();
return(dicSerialiser.Deserialize(context, args));
}
return(bsonSerializer.Deserialize(context, args));
}
catch (Exception e)
{
if (e.Message.Contains("Could not load file or assembly"))
{
Engine.Reflection.Compute.RecordError(e.Message);
}
context.Reader.ReturnToBookmark(bookmark);
DeprecatedSerializer deprecatedSerialiser = new DeprecatedSerializer();
return(deprecatedSerialiser.Deserialize(context, args));
}
}
private static bool IsValidBsonType(
BsonType bsonType
)
{
return(validBsonTypes[(byte)bsonType]);
}
private bool ReadNormal()
{
switch (CurrentState)
{
case State.Start:
{
JsonToken token = (!_readRootValueAsArray) ? JsonToken.StartObject : JsonToken.StartArray;
BsonType type = (!_readRootValueAsArray) ? BsonType.Object : BsonType.Array;
SetToken(token);
ContainerContext newContext = new ContainerContext(type);
PushContext(newContext);
newContext.Length = ReadInt32();
return(true);
}
case State.Complete:
case State.Closed:
return(false);
case State.Property:
{
ReadType(_currentElementType);
return(true);
}
case State.ObjectStart:
case State.ArrayStart:
case State.PostValue:
ContainerContext context = _currentContext;
if (context == null)
{
return(false);
}
int lengthMinusEnd = context.Length - 1;
if (context.Position < lengthMinusEnd)
{
if (context.Type == BsonType.Array)
{
ReadElement();
ReadType(_currentElementType);
return(true);
}
else
{
SetToken(JsonToken.PropertyName, ReadElement());
return(true);
}
}
else if (context.Position == lengthMinusEnd)
{
if (ReadByte() != 0)
{
throw JsonReaderException.Create(this, "Unexpected end of object byte value.");
}
PopContext();
if (_currentContext != null)
{
MovePosition(context.Length);
}
JsonToken endToken = (context.Type == BsonType.Object) ? JsonToken.EndObject : JsonToken.EndArray;
SetToken(endToken);
return(true);
}
else
{
throw JsonReaderException.Create(this, "Read past end of current container context.");
}
case State.ConstructorStart:
break;
case State.Constructor:
break;
case State.Error:
break;
case State.Finished:
break;
default:
throw new ArgumentOutOfRangeException();
}
return(false);
}
/// <summary>
/// Verifies the current state and BsonType of the reader.
/// </summary>
/// <param name="methodName">The name of the method calling this one.</param>
/// <param name="requiredBsonType">The required BSON type.</param>
protected void VerifyBsonType(string methodName, BsonType requiredBsonType)
{
if (_state == BsonReaderState.Initial || _state == BsonReaderState.ScopeDocument || _state == BsonReaderState.Type)
{
ReadBsonType();
}
if (_state == BsonReaderState.Name)
{
// ignore name
SkipName();
}
if (_state != BsonReaderState.Value)
{
ThrowInvalidState(methodName, BsonReaderState.Value);
}
if (_currentBsonType != requiredBsonType)
{
var message = string.Format(
"{0} can only be called when CurrentBsonType is {1}, not when CurrentBsonType is {2}.",
methodName, requiredBsonType, _currentBsonType);
throw new InvalidOperationException(message);
}
}
/// <summary>
/// Writes a BsonType to the stream.
/// </summary>
/// <param name="stream">The stream.</param>
/// <param name="value">The value.</param>
public static void WriteBsonType(this BsonStream stream, BsonType value)
{
if (stream == null)
{
throw new ArgumentNullException("stream");
}
stream.WriteByte((byte)value);
}
private void ReadType(BsonType type)
{
switch (type)
{
case BsonType.Number:
double d = ReadDouble();
if (_floatParseHandling == FloatParseHandling.Decimal)
SetToken(JsonToken.Float, Convert.ToDecimal(d, CultureInfo.InvariantCulture));
else
SetToken(JsonToken.Float, d);
break;
case BsonType.String:
case BsonType.Symbol:
SetToken(JsonToken.String, ReadLengthString());
break;
case BsonType.Object:
{
SetToken(JsonToken.StartObject);
ContainerContext newContext = new ContainerContext(BsonType.Object);
PushContext(newContext);
newContext.Length = ReadInt32();
break;
}
case BsonType.Array:
{
SetToken(JsonToken.StartArray);
ContainerContext newContext = new ContainerContext(BsonType.Array);
PushContext(newContext);
newContext.Length = ReadInt32();
break;
}
case BsonType.Binary:
SetToken(JsonToken.Bytes, ReadBinary());
break;
case BsonType.Undefined:
SetToken(JsonToken.Undefined);
break;
case BsonType.Oid:
byte[] oid = ReadBytes(12);
SetToken(JsonToken.Bytes, oid);
break;
case BsonType.Boolean:
bool b = Convert.ToBoolean(ReadByte());
SetToken(JsonToken.Boolean, b);
break;
case BsonType.Date:
long ticks = ReadInt64();
DateTime utcDateTime = DateTimeUtils.ConvertJavaScriptTicksToDateTime(ticks);
DateTime dateTime;
switch (DateTimeKindHandling)
{
case DateTimeKind.Unspecified:
dateTime = DateTime.SpecifyKind(utcDateTime, DateTimeKind.Unspecified);
break;
case DateTimeKind.Local:
dateTime = utcDateTime.ToLocalTime();
break;
default:
dateTime = utcDateTime;
break;
}
SetToken(JsonToken.Date, dateTime);
break;
case BsonType.Null:
SetToken(JsonToken.Null);
break;
case BsonType.Regex:
string expression = ReadString();
string modifiers = ReadString();
string regex = @"/" + expression + @"/" + modifiers;
SetToken(JsonToken.String, regex);
break;
case BsonType.Reference:
SetToken(JsonToken.StartObject);
_bsonReaderState = BsonReaderState.ReferenceStart;
break;
case BsonType.Code:
SetToken(JsonToken.String, ReadLengthString());
break;
case BsonType.CodeWScope:
SetToken(JsonToken.StartObject);
_bsonReaderState = BsonReaderState.CodeWScopeStart;
break;
case BsonType.Integer:
SetToken(JsonToken.Integer, (long)ReadInt32());
break;
case BsonType.TimeStamp:
case BsonType.Long:
SetToken(JsonToken.Integer, ReadInt64());
break;
default:
throw new ArgumentOutOfRangeException("type", "Unexpected BsonType value: " + type);
}
}
/// <summary>
/// Initializes a new instance of the TimeSpanSerializationOptions class.
/// </summary>
/// <param name="representation">The representation for serialized TimeSpans.</param>
/// <param name="units">The units for serialized TimeSpans.</param>
public TimeSpanSerializationOptions(BsonType representation, TimeSpanUnits units)
{
_representation = representation;
_units = units;
}
/// <summary>
/// Initializes a new instance of the KeyValuePairSerializationOptions class.
/// </summary>
/// <param name="representation">The representation to use for the KeyValuePair.</param>
/// <param name="keySerializationOptions">The serialization options for the key.</param>
/// <param name="valueSerializationOptions">The serialization options for the value.</param>
public KeyValuePairSerializationOptions(BsonType representation, IBsonSerializationOptions keySerializationOptions, IBsonSerializationOptions valueSerializationOptions)
{
_representation = representation;
_keySerializationOptions = keySerializationOptions;
_valueSerializationOptions = valueSerializationOptions;
}
// public methods
/// <summary>
/// Apply an attribute to these serialization options and modify the options accordingly.
/// </summary>
/// <param name="serializer">The serializer that these serialization options are for.</param>
/// <param name="attribute">The serialization options attribute.</param>
public override void ApplyAttribute(IBsonSerializer serializer, Attribute attribute)
{
EnsureNotFrozen();
var representationAttribute = attribute as BsonRepresentationAttribute;
if (representationAttribute != null)
{
_allowOverflow = representationAttribute.AllowOverflow;
_allowTruncation = representationAttribute.AllowTruncation;
_representation = representationAttribute.Representation;
return;
}
var message = string.Format("A serialization options attribute of type {0} cannot be applied to serialization options of type {1}.",
BsonUtils.GetFriendlyTypeName(attribute.GetType()), BsonUtils.GetFriendlyTypeName(GetType()));
throw new NotSupportedException(message);
}
protected BsonValue(BsonType type, object rawValue)
{
this.Type = type;
this.RawValue = rawValue;
}
// constructors
/// <summary>
/// Initializes a new instance of the BsonTimeSpanOptionsAttribute class.
/// </summary>
/// <param name="representation">The external representation.</param>
public BsonTimeSpanOptionsAttribute(BsonType representation)
{
_representation = representation;
}
public static Mapping FromTo(Type netType, BsonType bsonType)
{
return(new Mapping(netType, bsonType));
}
private string ReadElement()
{
_currentElementType = ReadType();
string elementName = ReadString();
return elementName;
}
/// <summary>
/// Initializes a new instance of the BsonTimeSpanOptionsAttribute class.
/// </summary>
/// <param name="representation">The external representation.</param>
/// <param name="units">The TimeSpanUnits.</param>
public BsonTimeSpanOptionsAttribute(BsonType representation, TimeSpanUnits units)
{
_representation = representation;
_units = units;
}
public ContainerContext(BsonType type)
{
Type = type;
}
// constructors
/// <summary>
/// Initializes a new instance of the BsonRepresentationAttribute class.
/// </summary>
/// <param name="representation">The external representation.</param>
public BsonRepresentationAttribute(BsonType representation)
{
_representation = representation;
}
