// public methods
/// <summary>
/// Deserializes the members.
/// </summary>
/// <param name="context">The deserialization context.</param>
/// <param name="memberHandler">The member handler.</param>
/// <returns>The found member flags.</returns>
public long DeserializeMembers(BsonDeserializationContext context, Action<string, long> memberHandler)
{
var reader = context.Reader;
var foundMemberFlags = 0L;
reader.ReadStartDocument();
while (reader.ReadBsonType() != 0)
{
var trieDecoder = new TrieNameDecoder<long>(_trie);
var elementName = reader.ReadName(trieDecoder);
long memberFlag;
if (trieDecoder.Found)
{
memberFlag = trieDecoder.Value;
}
else
{
if (_extraMemberFlag == 0)
{
throw new BsonSerializationException(string.Format(
"Invalid element: '{0}'.", elementName));
}
else
{
memberFlag = _extraMemberFlag;
}
}
memberHandler(elementName, memberFlag);
foundMemberFlags |= memberFlag;
}
reader.ReadEndDocument();
var missingRequiredMemberFlags = _requiredMemberFlags & ~foundMemberFlags;
if (missingRequiredMemberFlags != 0)
{
var missingRequiredMember = FindFirstMissingRequiredMember(missingRequiredMemberFlags);
throw new BsonSerializationException(string.Format(
"Missing element: '{0}'.", missingRequiredMember.ElementName));
}
return foundMemberFlags;
}
public override DateTime Deserialize(BsonDeserializationContext context, BsonDeserializationArgs args)
{
return(new DateTime(base.Deserialize(context, args).Ticks, DateTimeKind.Unspecified));
}
// public methods
/// <summary>
/// Deserializes a value.
/// </summary>
/// <param name="context">The deserialization context.</param>
/// <param name="args">The deserialization args.</param>
/// <returns>A deserialized value.</returns>
public virtual TValue Deserialize(BsonDeserializationContext context, BsonDeserializationArgs args)
{
throw CreateCannotBeDeserializedException();
}
public override decimal Deserialize(BsonDeserializationContext context, BsonDeserializationArgs args)
{
return(Math.Round(context.Reader.ReadInt64() / DecimalPlace, 4));
}
public override T Deserialize(BsonDeserializationContext context, BsonDeserializationArgs args)
{
var value = context.Reader.ReadString();
return((T)typeConverter.ConvertFromInvariantString(value));
}
protected override InsertRequest DeserializeValue(BsonDeserializationContext context, BsonDeserializationArgs args)
{
var document = BsonDocumentSerializer.Instance.Deserialize(context, args);
return(new InsertRequest(document));
}
public object Deserialize(BsonDeserializationContext context, BsonDeserializationArgs args)
{
var dbData = context.Reader.ReadInt32();
return((decimal)dbData / (decimal)100);
}
// protected methods
/// <summary>
/// Deserializes a value.
/// </summary>
/// <param name="context">The deserialization context.</param>
/// <param name="args">The deserialization args.</param>
/// <returns>A deserialized value.</returns>
protected override BsonObjectId DeserializeValue(BsonDeserializationContext context, BsonDeserializationArgs args)
{
var bsonReader = context.Reader;
return(new BsonObjectId(bsonReader.ReadObjectId()));
}
public override DateTime Deserialize(BsonDeserializationContext context, BsonDeserializationArgs args)
{
var bsonReader = context.Reader;
return(DateTime.ParseExact(bsonReader.ReadString(), "yyyy-MM-dd", DateTimeFormatInfo.InvariantInfo));
}
public Triplet Deserialize(BsonDeserializationContext context, BsonDeserializationArgs args)
{
return(BsonSerializer.Deserialize <Triplet>(context.Reader.ReadBytes()));
}
public override EncryptedString Deserialize(BsonDeserializationContext context, BsonDeserializationArgs args)
{
var encryptedString = context.Reader.ReadString();
return(_encrypter.DecryptStringWithPassword(encryptedString, _encryptionKey));
}
public override RawDictionary Deserialize(BsonDeserializationContext context, BsonDeserializationArgs args)
{
return(new RawDictionary(RawBsonDocumentSerializer.Instance.Deserialize(context, args)));
}
public override LazyDictionary Deserialize(BsonDeserializationContext context, BsonDeserializationArgs args)
{
var serialiazer = new LazyBsonDocumentSerializer();
return(new LazyDictionary(serialiazer.Deserialize(context, args)));
}
public override PSObject Deserialize(BsonDeserializationContext context, BsonDeserializationArgs args)
{
return(ReadCustomObject(context.Reader));
}
public override Collection.ISet <T> Deserialize(BsonDeserializationContext context, BsonDeserializationArgs args)
{
var enumerable = (IEnumerable <T>)_serializer.Deserialize(context, args);
return(new Collection.HashSet <T>(enumerable));
}
/*******************************************/
public override CustomObject Deserialize(BsonDeserializationContext context, BsonDeserializationArgs args)
{
var bsonReader = context.Reader;
var bsonType = bsonReader.CurrentBsonType;
if (bsonReader.State != BsonReaderState.Type)
{
bsonType = bsonReader.GetCurrentBsonType();
}
string message;
switch (bsonType)
{
case BsonType.Document:
var dynamicContext = context.With(ConfigureDeserializationContext);
bsonReader.ReadStartDocument();
CustomObject document = new CustomObject();
Dictionary <string, object> dic = document.CustomData;
while (bsonReader.ReadBsonType() != BsonType.EndOfDocument)
{
var name = bsonReader.ReadName();
var value = m_ObjectSerializer.Deserialize(dynamicContext);
switch (name)
{
case "Name":
document.Name = value as string;
break;
case "Tags":
document.Tags = new HashSet <string>(((List <object>)value).Cast <string>());
break;
case "BHoM_Guid":
document.BHoM_Guid = new Guid(value as string);
break;
case "CustomData":
while (value is CustomObject)
{
value = ((CustomObject)value).CustomData;
}
if (value is Dictionary <string, object> )
{
Dictionary <string, object> customData = value as Dictionary <string, object>;
if (customData.Count > 0)
{
dic["AdditionalData"] = value;
}
}
break;
default:
dic[name] = value;
break;
}
}
bsonReader.ReadEndDocument();
return(document);
default:
message = string.Format("Cannot deserialize a '{0}' from BsonType '{1}'.", BsonUtils.GetFriendlyTypeName(typeof(CustomObject)), bsonType);
throw new FormatException(message);
}
}
public override BsonInt32 Deserialize(BsonDeserializationContext context, BsonDeserializationArgs args)
{
var type = context.Reader.GetCurrentBsonType();
var dval = 0.0;
String s;
switch (type)
{
case BsonType.Int32:
return(context.Reader.ReadInt32());
case BsonType.Int64:
dval = context.Reader.ReadInt64();
break;
case BsonType.Double:
dval = context.Reader.ReadDouble();
break;
case BsonType.Null:
context.Reader.ReadNull();
break;
case BsonType.String:
s = context.Reader.ReadString();
try
{
dval = double.Parse(s);
}
catch (Exception)
{
}
break;
case BsonType.ObjectId:
s = context.Reader.ReadObjectId().ToString();
try
{
dval = double.Parse(s);
}
catch (Exception)
{
}
break;
case BsonType.JavaScript:
s = context.Reader.ReadJavaScript();
try
{
dval = double.Parse(s);
}
catch (Exception)
{
}
break;
case BsonType.Decimal128:
dval = System.Convert.ToDouble(context.Reader.ReadDecimal128());
break;
case BsonType.Boolean:
dval = System.Convert.ToDouble(context.Reader.ReadBoolean());
break;
}
return(System.Convert.ToInt32(dval));
}
/*******************************************/
public override MethodBase Deserialize(BsonDeserializationContext context, BsonDeserializationArgs args)
{
var bsonReader = context.Reader;
bsonReader.ReadStartDocument();
string text = bsonReader.ReadName();
if (text == m_DiscriminatorConvention.ElementName)
{
bsonReader.SkipValue();
}
bsonReader.ReadName();
string typeName = bsonReader.ReadString();
bsonReader.ReadName();
string methodName = bsonReader.ReadString();
List <string> paramTypesJson = new List <string>();
bsonReader.ReadName();
bsonReader.ReadStartArray();
while (bsonReader.ReadBsonType() != BsonType.EndOfDocument)
{
paramTypesJson.Add(bsonReader.ReadString());
}
bsonReader.ReadEndArray();
string version = "";
if (bsonReader.FindElement("_bhomVersion"))
{
version = bsonReader.ReadString();
}
context.Reader.ReadEndDocument();
try
{
MethodBase method = GetMethod(methodName, typeName, paramTypesJson);
if (method == null || method.IsDeprecated())
{
// Try to upgrade through versioning
BsonDocument doc = new BsonDocument();
doc["_t"] = "System.Reflection.MethodBase";
doc["TypeName"] = typeName;
doc["MethodName"] = methodName;
doc["Parameters"] = new BsonArray(paramTypesJson);
BsonDocument newDoc = Versioning.Convert.ToNewVersion(doc, version);
if (newDoc != null && newDoc.Contains("TypeName") && newDoc.Contains("MethodName") && newDoc.Contains("Parameters"))
{
method = GetMethod(newDoc["MethodName"].AsString, newDoc["TypeName"].AsString, newDoc["Parameters"].AsBsonArray.Select(x => x.AsString).ToList());
}
}
if (method == null)
{
Reflection.Compute.RecordError("Method " + methodName + " from " + typeName + " failed to deserialise.");
}
return(method);
}
catch
{
Reflection.Compute.RecordError("Method " + methodName + " from " + typeName + " failed to deserialise.");
return(null);
}
}
/***************************************************/
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
{
actualType = typeof(IDeprecated);
}
finally
{
context.Reader.ReturnToBookmark(bookmark);
}
if (actualType == null)
{
return(null);
}
// Make sure the type is not deprecated
if (Config.AllowUpgradeFromBson && actualType.IIsDeprecated() && !Config.TypesWithoutUpgrade.Contains(actualType))
{
actualType = typeof(IDeprecated);
}
// 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
{
IBsonSerializer bsonSerializer = BsonSerializer.LookupSerializer(actualType);
return(bsonSerializer.Deserialize(context, args));
}
catch (Exception e)
{
context.Reader.ReturnToBookmark(bookmark);
if (e is FormatException && e.InnerException != null && e.InnerException is FormatException)
{
// A child of the object is causing problems. Try to recover from custom object
IBsonSerializer customSerializer = BsonSerializer.LookupSerializer(typeof(CustomObject));
object result = customSerializer.Deserialize(context, args);
Guid objectId = ((CustomObject)result).BHoM_Guid;
if (!Config.TypesWithoutUpgrade.Contains(actualType))
{
if (m_StackCounter.ContainsKey(objectId))
{
m_StackCounter[objectId] += 1;
}
else
{
m_StackCounter[objectId] = 1;
}
if (m_StackCounter[objectId] < 10)
{
result = Convert.FromBson(result.ToBson());
m_StackCounter.Remove(objectId);
}
}
if (result is CustomObject)
{
Engine.Reflection.Compute.RecordWarning("The type " + actualType.FullName + " is unknown -> data returned as custom objects.");
Config.TypesWithoutUpgrade.Add(actualType);
}
return(result);
}
else if (actualType != typeof(IDeprecated))
{
// Try the deprecated object serialiser
IBsonSerializer deprecatedSerializer = BsonSerializer.LookupSerializer(typeof(IDeprecated));
return(deprecatedSerializer.Deserialize(context, args));
}
else
{
// Last resort: just return the custom object
Engine.Reflection.Compute.RecordWarning("The type " + actualType.FullName + " is unknown -> data returned as custom objects.");
IBsonSerializer customSerializer = BsonSerializer.LookupSerializer(typeof(CustomObject));
return(customSerializer.Deserialize(context, args));
}
}
}
// protected methods
/// <summary>
/// Deserializes a value.
/// </summary>
/// <param name="context">The deserialization context.</param>
/// <param name="args">The deserialization args.</param>
/// <returns>A deserialized value.</returns>
protected override BsonRegularExpression DeserializeValue(BsonDeserializationContext context, BsonDeserializationArgs args)
{
var bsonReader = context.Reader;
return(bsonReader.ReadRegularExpression());
}
public override SecureString Deserialize(BsonDeserializationContext context, BsonDeserializationArgs args)
{
return(context.Reader.ReadBytes().ToSecureString());
}
private TCommandResult ProcessResponse(ConnectionId connectionId, CommandMessage responseMessage)
{
using (new CommandMessageDisposer(responseMessage))
{
var rawDocument = responseMessage.Sections.OfType <Type0CommandMessageSection <RawBsonDocument> >().Single().Document;
var binaryReaderSettings = new BsonBinaryReaderSettings();
if (_messageEncoderSettings != null)
{
binaryReaderSettings.Encoding = _messageEncoderSettings.GetOrDefault <UTF8Encoding>(MessageEncoderSettingsName.ReadEncoding, Utf8Encodings.Strict);
binaryReaderSettings.GuidRepresentation = _messageEncoderSettings.GetOrDefault <GuidRepresentation>(MessageEncoderSettingsName.GuidRepresentation, GuidRepresentation.CSharpLegacy);
}
;
BsonValue clusterTime;
if (rawDocument.TryGetValue("$clusterTime", out clusterTime))
{
// note: we are assuming that _session is an instance of ClusterClockAdvancingClusterTime
// and that calling _session.AdvanceClusterTime will have the side effect of advancing the cluster's ClusterTime also
var materializedClusterTime = ((RawBsonDocument)clusterTime).Materialize(binaryReaderSettings);
_session.AdvanceClusterTime(materializedClusterTime);
}
BsonValue operationTime;
if (rawDocument.TryGetValue("operationTime", out operationTime))
{
_session.AdvanceOperationTime(operationTime.AsBsonTimestamp);
}
if (rawDocument.GetValue("ok", false).ToBoolean())
{
if (rawDocument.TryGetValue("recoveryToken", out var rawRecoveryToken))
{
var recoveryToken = ((RawBsonDocument)rawRecoveryToken).Materialize(binaryReaderSettings);
_session.CurrentTransaction.RecoveryToken = recoveryToken;
}
}
else
{
var materializedDocument = rawDocument.Materialize(binaryReaderSettings);
var commandName = _command.GetElement(0).Name;
if (commandName == "$query")
{
commandName = _command["$query"].AsBsonDocument.GetElement(0).Name;
}
var notPrimaryOrNodeIsRecoveringException = ExceptionMapper.MapNotPrimaryOrNodeIsRecovering(connectionId, _command, materializedDocument, "errmsg");
if (notPrimaryOrNodeIsRecoveringException != null)
{
throw notPrimaryOrNodeIsRecoveringException;
}
var mappedException = ExceptionMapper.Map(connectionId, materializedDocument);
if (mappedException != null)
{
throw mappedException;
}
string message;
BsonValue errmsgBsonValue;
if (materializedDocument.TryGetValue("errmsg", out errmsgBsonValue) && errmsgBsonValue.IsString)
{
var errmsg = errmsgBsonValue.ToString();
message = string.Format("Command {0} failed: {1}.", commandName, errmsg);
}
else
{
message = string.Format("Command {0} failed.", commandName);
}
var exception = new MongoCommandException(connectionId, message, _command, materializedDocument);
// https://jira.mongodb.org/browse/CSHARP-2678
if (IsRetryableWriteExceptionAndDeploymentDoesNotSupportRetryableWrites(exception))
{
throw WrapNotSupportedRetryableWriteException(exception);
}
else
{
throw exception;
}
}
if (rawDocument.Contains("writeConcernError"))
{
var materializedDocument = rawDocument.Materialize(binaryReaderSettings);
var writeConcernError = materializedDocument["writeConcernError"].AsBsonDocument;
var message = writeConcernError.AsBsonDocument.GetValue("errmsg", null)?.AsString;
var writeConcernResult = new WriteConcernResult(materializedDocument);
throw new MongoWriteConcernException(connectionId, message, writeConcernResult);
}
using (var stream = new ByteBufferStream(rawDocument.Slice, ownsBuffer: false))
{
using (var reader = new BsonBinaryReader(stream, binaryReaderSettings))
{
var context = BsonDeserializationContext.CreateRoot(reader);
return(_resultSerializer.Deserialize(context));
}
}
}
}
public override Name Deserialize(BsonDeserializationContext context, BsonDeserializationArgs args)
{
return(new Name(context.Reader.ReadString()));
}
// protected methods
/// <summary>
/// Deserializes a value.
/// </summary>
/// <param name="context">The deserialization context.</param>
/// <param name="args">The deserialization args.</param>
/// <returns>The value.</returns>
protected override GeoJsonLineStringCoordinates <TCoordinates> DeserializeValue(BsonDeserializationContext context, BsonDeserializationArgs args)
{
var bsonReader = context.Reader;
var positions = new List <TCoordinates>();
bsonReader.ReadStartArray();
while (bsonReader.ReadBsonType() != BsonType.EndOfDocument)
{
var position = _coordinatesSerializer.Deserialize(context);
positions.Add(position);
}
bsonReader.ReadEndArray();
return(new GeoJsonLineStringCoordinates <TCoordinates>(positions));
}
/// <summary>
/// Deserializes a value.
/// </summary>
/// <param name="context">The deserialization context.</param>
/// <param name="args">The deserialization args.</param>
/// <returns>A deserialized value.</returns>
public override Timestamp Deserialize(BsonDeserializationContext context, BsonDeserializationArgs args)
{
return(_serializer.Deserialize(context, args));
}
// explicit interface implementations
object IBsonSerializer.Deserialize(BsonDeserializationContext context, BsonDeserializationArgs args)
{
return(Deserialize(context, args));
}
// methods
/// <inheritdoc/>
public override TResult Deserialize(BsonDeserializationContext context, BsonDeserializationArgs args)
{
return(_resultSerializer.Deserialize(context));
}
public override Status Deserialize(BsonDeserializationContext context, BsonDeserializationArgs args)
{
var value = context.Reader.ReadString();
return(new Status(value));
}
public override DateTime Deserialize(BsonDeserializationContext context)
{
var bsonReader = context.Reader;
return(XmlConvert.ToDateTime(bsonReader.ReadString(), XmlDateTimeSerializationMode.RoundtripKind));
}
public override JObject Deserialize(BsonDeserializationContext context, BsonDeserializationArgs args)
{
var myBsonDoc = BsonDocumentSerializer.Instance.Deserialize(context);
return(JObject.Parse(myBsonDoc.ToString()));
}
// protected methods
/// <summary>
/// Deserializes a value.
/// </summary>
/// <param name="context">The deserialization context.</param>
/// <param name="args">The deserialization args.</param>
/// <returns>A deserialized value.</returns>
protected override BsonDouble DeserializeValue(BsonDeserializationContext context, BsonDeserializationArgs args)
{
var bsonReader = context.Reader;
return((BsonDouble)bsonReader.ReadDouble());
}
