protected override ObjectTypeDescriptor <dynamic, dynamic> Mapping <T>(ObjectTypeDescriptor <dynamic, dynamic> o)
{
var metadataPropertyKey = Metadata.Key;
return(o
.Properties(osp => osp
.UriKeyword()
.Keyword(ky =>
{
ky
.Name(NodeNames.Value)
.Fields(ff =>
{
ff.DmpStandardEnglishAnalyzer();
ff.DmpNgramAnalyzer();
if (Metadata.Properties.ContainsKey(Strings.Taxonomy))
{
ff.DmpTaxonomyAnalyzer(metadataPropertyKey);
ff.DmpNgramTaxonomyAnalyzer(metadataPropertyKey);
ff.ExactTaxonomyAnalyzer(metadataPropertyKey);
}
return ff;
});
if (typeof(T) != typeof(LinkedTypesOptions))
{
ky.CopyTo(cc => cc.Fields(Strings.DidYouMeanTrigram));
}
return ky;
})
));
}
private MethodCallBuilder CreateBuildDataStatement(ObjectTypeDescriptor concreteType)
{
MethodCallBuilder returnStatement = MethodCallBuilder
.New()
.SetNew()
.SetMethodName(
$"{concreteType.RuntimeType.Namespace}.State." +
CreateDataTypeName(concreteType.Name))
.AddArgument("typename");
foreach (PropertyDescriptor property in concreteType.Properties)
{
if (property.Name.Value.EqualsOrdinal(WellKnownNames.TypeName))
{
continue;
}
returnStatement.AddArgument(
CodeBlockBuilder
.New()
.AddCode($"{GetParameterName(property.Name)}: ")
.AddCode(BuildUpdateMethodCall(property)));
}
return(returnStatement);
}
protected override ObjectTypeDescriptor <dynamic, dynamic> Mapping <T>(ObjectTypeDescriptor <dynamic, dynamic> o)
{
var currentOptionType = typeof(T).ToString();
// Check if rule is applied in linked types.
// If true, do not apply all nested fields of this property
if (currentOptionType.Equals(typeof(LinkedTypesOptions).ToString()))
{
return(o.Properties(pn => pn
.UriKeyword()
.EdgeKeyword()
.ValueKeyword()
));
}
else
{
var nestedProperties = CollectProperties(Metadata.NestedMetadata);
return(o.Properties(pn => pn
.UriKeyword()
.EdgeKeyword()
.CustomNode(NodeNames.Value, od => od
.Properties(pd => pd
.AddNestedFields(nestedProperties)
)
)
));
}
}
private ICode CreateEntityConstructorCall(
ObjectTypeDescriptor objectTypeDescriptor,
bool assignDefault)
{
var propertyLookup = objectTypeDescriptor.Properties.ToDictionary(x => x.Name.Value);
MethodCallBuilder newEntity = MethodCallBuilder
.Inline()
.SetNew()
.SetMethodName(objectTypeDescriptor.EntityTypeDescriptor.RuntimeType.ToString());
foreach (PropertyDescriptor property in
objectTypeDescriptor.EntityTypeDescriptor.Properties.Values)
{
if (propertyLookup.TryGetValue(property.Name.Value, out var ownProperty))
{
newEntity.AddArgument(BuildUpdateMethodCall(ownProperty));
}
else if (assignDefault)
{
newEntity.AddArgument("default!");
}
else
{
newEntity.AddArgument($"{_entity}.{property.Name}");
}
}
return(MethodCallBuilder
.New()
.SetMethodName(_session, "SetEntity")
.AddArgument(_entityId)
.AddArgument(newEntity));
}
protected override ObjectTypeDescriptor <dynamic, dynamic> Mapping <T>(ObjectTypeDescriptor <dynamic, dynamic> o)
{
return(o
.Properties(osp => osp
.Keyword(ky =>
{
ky
.Name(NodeNames.Value)
.Fields(ff => ff
.DmpStandardEnglishAnalyzer()
.DmpNgramAnalyzer()
);
if (typeof(T) != typeof(LinkedTypesOptions))
{
ky.CopyTo(cc => cc
.Fields(
Strings.DidYouMeanTrigram,
Strings.AutoCompleteFilter,
Strings.AutoCompleteTerms
)
);
}
return ky;
})
));
}
private IfBuilder GenerateComplexDataInterfaceIfClause(
ObjectTypeDescriptor objectTypeDescriptor,
string variableName)
{
var matchedTypeName = GetParameterName(objectTypeDescriptor.Name);
// since we want to create the data name we will need to craft the type name
// by hand by using the GraphQL type name and the state namespace.
var dataTypeName = new RuntimeTypeInfo(
CreateDataTypeName(objectTypeDescriptor.Name),
$"{objectTypeDescriptor.RuntimeType.Namespace}.State");
var block = CodeBlockBuilder.New();
MethodCallBuilder constructorCall = MethodCallBuilder
.Inline()
.SetNew()
.SetMethodName(objectTypeDescriptor.RuntimeType.ToString());
foreach (PropertyDescriptor prop in objectTypeDescriptor.Properties)
{
if (prop.Type.IsEntityType())
{
constructorCall.AddArgument(BuildMapMethodCall(matchedTypeName, prop));
}
else if (prop.Type.IsNonNullableType())
{
if (prop.Type.NamedType() is ILeafTypeDescriptor
{
RuntimeType: { IsValueType: true }
})
protected override ObjectTypeDescriptor <dynamic, dynamic> Mapping <T>(ObjectTypeDescriptor <dynamic, dynamic> o)
{
return(o
.Properties(osp => osp
.ValueKeyword()
));
}
private static ICode GenerateEntityHandlerIfClause(
ObjectTypeDescriptor objectTypeDescriptor,
bool isNonNullable)
{
var dataMapperName =
GetFieldName(
CreateEntityMapperName(
objectTypeDescriptor.RuntimeType.Name,
objectTypeDescriptor.Name));
MethodCallBuilder constructorCall = MethodCallBuilder
.New()
.SetReturn()
.SetWrapArguments()
.SetMethodName(dataMapperName, nameof(IEntityMapper <object, object> .Map));
MethodCallBuilder argument = MethodCallBuilder
.Inline()
.SetMethodName(StoreFieldName, nameof(IEntityStore.GetEntity))
.AddGeneric(CreateEntityTypeName(objectTypeDescriptor.Name))
.AddArgument(isNonNullable ? _entityId : $"{_entityId}.Value");
constructorCall.AddArgument(
NullCheckBuilder
.New()
.SetDetermineStatement(false)
.SetCondition(argument)
.SetCode(ExceptionBuilder.Inline(TypeNames.GraphQLClientException)));
IfBuilder ifCorrectType = IfBuilder
.New()
.AddCode(constructorCall)
.SetCondition(
MethodCallBuilder
.Inline()
.SetMethodName(
isNonNullable
? new[]
{
_entityId,
nameof(EntityId.Name),
nameof(string.Equals)
}
: new[]
{
_entityId,
nameof(Nullable <EntityId> .Value),
nameof(EntityId.Name),
nameof(string.Equals)
})
.AddArgument(objectTypeDescriptor.Name.AsStringToken())
.AddArgument(TypeNames.OrdinalStringComparison));
return(CodeBlockBuilder
.New()
.AddEmptyLine()
.AddCode(ifCorrectType));
}
private IfBuilder GenerateDataInterfaceIfClause(
ObjectTypeDescriptor objectTypeDescriptor,
bool isNonNullable,
string variableName)
{
ICode ifCondition = MethodCallBuilder
.Inline()
.SetMethodName(
_dataParameterName.MakeNullable(!isNonNullable),
WellKnownNames.TypeName,
nameof(string.Equals))
.AddArgument(objectTypeDescriptor.Name.AsStringToken())
.AddArgument(TypeNames.OrdinalStringComparison);
if (!isNonNullable)
{
ifCondition = NullCheckBuilder
.New()
.SetCondition(ifCondition)
.SetSingleLine()
.SetDetermineStatement(false)
.SetCode("false");
}
MethodCallBuilder constructorCall = MethodCallBuilder
.Inline()
.SetNew()
.SetMethodName(objectTypeDescriptor.RuntimeType.Name);
foreach (PropertyDescriptor prop in objectTypeDescriptor.Properties)
{
var propAccess = $"{_dataParameterName}.{prop.Name}";
if (prop.Type.IsEntityType() || prop.Type.IsDataType())
{
constructorCall.AddArgument(BuildMapMethodCall(_dataParameterName, prop, true));
}
else if (prop.Type.IsNullableType())
{
constructorCall.AddArgument(propAccess);
}
else
{
constructorCall
.AddArgument(
NullCheckBuilder
.Inline()
.SetCondition(propAccess)
.SetCode(ExceptionBuilder.Inline(TypeNames.ArgumentNullException)));
}
}
return(IfBuilder
.New()
.SetCondition(ifCondition)
.AddCode(AssignmentBuilder
.New()
.SetLefthandSide(variableName)
.SetRighthandSide(constructorCall)));
}
public void SetUp()
{
var objectTypeId = new ObjectTypeId(new Guid(objectTypeIdValue));
var repository = new ObjectTypeDescriptorRepository();
repository.RegisterUsingReflection(typeof(TestingObject));
typeDescriptor = repository.GetByTypeId(objectTypeId);
}
public void SetUp()
{
var objectTypeId = new ObjectTypeId(new Guid(objectTypeIdValue));
var repository = new ObjectTypeDescriptorRepository();
repository.RegisterUsingReflection(typeof(TestingObject));
typeDescriptor = repository.GetByTypeId(objectTypeId);
}
protected override ObjectTypeDescriptor <dynamic, dynamic> Mapping <T>(ObjectTypeDescriptor <dynamic, dynamic> o)
{
return(o
.Properties(osp => osp
.Date(ky => ky
.Name(NodeNames.Value)
)
));
}
protected override ObjectTypeDefinition CreateDefinition(
ITypeDiscoveryContext context)
{
var descriptor = ObjectTypeDescriptor.New <T>(context.DescriptorContext);
_configure !(descriptor);
_configure = null;
return(descriptor.CreateDefinition());
}
public void It_throws_exception_when_trying_to_register_two_types_with_same_id()
{
var objectTypeId = ObjectTypeId.NewUniqueId();
var repository = new ObjectTypeDescriptorRepository();
var firstTypeDescriptor = new ObjectTypeDescriptor(typeof(object), objectTypeId, new AttributeDescriptor[] { }, new RelationDescriptor[] { });
var secondTypeDescriptor = new ObjectTypeDescriptor(typeof(int), objectTypeId, new AttributeDescriptor[] { }, new RelationDescriptor[] { });
repository.RegisterTypeDescriptor(firstTypeDescriptor);
Assert.Throws<InvalidOperationException>(() => repository.RegisterTypeDescriptor(secondTypeDescriptor));
}
public void It_throws_exception_when_trying_to_register_two_types_with_same_id()
{
var objectTypeId = ObjectTypeId.NewUniqueId();
var repository = new ObjectTypeDescriptorRepository();
var firstTypeDescriptor = new ObjectTypeDescriptor(typeof(object), objectTypeId, new AttributeDescriptor[] { }, new RelationDescriptor[] { });
var secondTypeDescriptor = new ObjectTypeDescriptor(typeof(int), objectTypeId, new AttributeDescriptor[] { }, new RelationDescriptor[] { });
repository.RegisterTypeDescriptor(firstTypeDescriptor);
Assert.Throws <InvalidOperationException>(() => repository.RegisterTypeDescriptor(secondTypeDescriptor));
}
public static ObjectTypeDescriptor <dynamic, dynamic> NestedNodeProperties(
this ObjectTypeDescriptor <dynamic, dynamic> o)
{
return(o
.Properties(op => op
.UriKeyword()
.Keyword(ky => ky.Name(NodeNames.Value)
.Fields(ff => ff.DmpNgramAnalyzer().DmpStandardEnglishAnalyzer())
)
));
}
public ITypeDescriptor Create(Type type)
{
SerializerTypeInfo result;
if (_typeOrDescriptor2Info.TryGetValue(type, out result))
{
return(result.Descriptor);
}
if (_typeOrDescriptor2InfoNew.TryGetValue(type, out result))
{
return(result.Descriptor);
}
ITypeDescriptor desc = null;
if (!type.IsSubclassOf(typeof(Delegate)))
{
if (type.IsGenericType)
{
if (type.GetGenericTypeDefinition().InheritsOrImplements(typeof(IList <>)))
{
desc = new ListTypeDescriptor(this, type);
}
else if (type.GetGenericTypeDefinition().InheritsOrImplements(typeof(IDictionary <,>)))
{
desc = new DictionaryTypeDescriptor(this, type);
}
}
else if (type.IsArray)
{
desc = new ListTypeDescriptor(this, type);
}
else if (type.IsEnum)
{
desc = new EnumTypeDescriptor(this, type);
}
else
{
desc = new ObjectTypeDescriptor(this, type);
}
}
if (desc == null)
{
throw new BTDBException("Don't know how to serialize type " + type.ToSimpleName());
}
result = new SerializerTypeInfo
{
Id = 0,
Descriptor = desc
};
_typeOrDescriptor2InfoNew[desc] = result;
_typeOrDescriptor2InfoNew[type] = result;
desc.FinishBuildFromType(this);
return(desc);
}
public void It_returns_object_type_by_its_id()
{
var objectTypeId = ObjectTypeId.NewUniqueId();
var repository = new ObjectTypeDescriptorRepository();
var typeDescriptor = new ObjectTypeDescriptor(typeof(object), objectTypeId, new AttributeDescriptor[] {},
new RelationDescriptor[] {});
repository.RegisterTypeDescriptor(typeDescriptor);
var registered = repository.GetByTypeId(objectTypeId);
Assert.IsNotNull(registered);
}
public void It_returns_object_type_by_its_id()
{
var objectTypeId = ObjectTypeId.NewUniqueId();
var repository = new ObjectTypeDescriptorRepository();
var typeDescriptor = new ObjectTypeDescriptor(typeof (object), objectTypeId, new AttributeDescriptor[] {},
new RelationDescriptor[] {});
repository.RegisterTypeDescriptor(typeDescriptor);
var registered = repository.GetByTypeId(objectTypeId);
Assert.IsNotNull(registered);
}
private static ICode GenerateEntityHandlerIfClause(
ObjectTypeDescriptor objectTypeDescriptor,
bool isNonNullable)
{
var dataMapperName =
GetFieldName(
CreateEntityMapperName(
objectTypeDescriptor.RuntimeType.Name,
objectTypeDescriptor.Name));
var ifCorrectType = IfBuilder.New();
if (isNonNullable)
{
ifCorrectType.SetCondition(
$"{EntityIdParamName}.Name.Equals(\"" +
$"{objectTypeDescriptor.Name}\", " +
$"{TypeNames.OrdinalStringComparison})");
}
else
{
ifCorrectType.SetCondition(
$"{EntityIdParamName}.Value.Name.Equals(\"" +
$"{objectTypeDescriptor.Name}\", " +
$"{TypeNames.OrdinalStringComparison})");
}
MethodCallBuilder constructorCall = MethodCallBuilder.New()
.SetPrefix($"return {dataMapperName}.")
.SetWrapArguments()
.SetMethodName(nameof(IEntityMapper <object, object> .Map));
MethodCallBuilder argument = MethodCallBuilder.New()
.SetMethodName($"{StoreFieldName}.{nameof(IEntityStore.GetEntity)}")
.SetDetermineStatement(false)
.AddGeneric(CreateEntityTypeName(objectTypeDescriptor.Name))
.AddArgument(isNonNullable ? EntityIdParamName : $"{EntityIdParamName}.Value");
constructorCall.AddArgument(
NullCheckBuilder.New()
.SetDetermineStatement(false)
.SetCondition(argument)
.SetCode(ExceptionBuilder
.New(TypeNames.GraphQLClientException)
.SetDetermineStatement(false)));
ifCorrectType.AddCode(constructorCall);
return(CodeBlockBuilder.New()
.AddEmptyLine()
.AddCode(ifCorrectType));
}
protected override ObjectTypeDescriptor <dynamic, dynamic> Mapping <T>(ObjectTypeDescriptor <dynamic, dynamic> o)
{
return(o
.Properties(osp => osp
.UriKeyword()
.Keyword(ky =>
{
ky
.Name(NodeNames.Value)
.Fields(ff => ff
.DmpStandardEnglishAnalyzer()
);
return ky;
})
));
}
private IfBuilder GenerateDataInterfaceIfClause(
ObjectTypeDescriptor objectTypeDescriptor,
bool isNonNullable,
string variableName)
{
var ifCorrectType = IfBuilder.New();
if (isNonNullable)
{
ifCorrectType.SetCondition(
$"{_dataParameterName}.__typename.Equals(\"" +
$"{objectTypeDescriptor.Name}\", " +
$"{TypeNames.OrdinalStringComparison})");
}
else
{
ifCorrectType.SetCondition(
$"{_dataParameterName}?.__typename.Equals(\"" +
$"{objectTypeDescriptor.Name}\", " +
$"{TypeNames.OrdinalStringComparison}) ?? false");
}
var constructorCall = MethodCallBuilder.New()
.SetPrefix($"{variableName} = new ")
.SetMethodName(objectTypeDescriptor.RuntimeType.Name);
foreach (PropertyDescriptor prop in objectTypeDescriptor.Properties)
{
var propAccess = $"{_dataParameterName}.{prop.Name}";
if (prop.Type.IsEntityType())
{
constructorCall.AddArgument(BuildMapMethodCall(_dataParameterName, prop, true));
}
else
{
constructorCall.AddArgument(
$"{propAccess} ?? throw new {TypeNames.ArgumentNullException}()");
}
}
ifCorrectType.AddCode(constructorCall);
return(ifCorrectType);
}
protected override ObjectTypeDefinition CreateDefinition(
ITypeDiscoveryContext context)
{
try
{
if (Definition is null)
{
var descriptor = ObjectTypeDescriptor.FromSchemaType(
context.DescriptorContext,
GetType());
_configure !.Invoke(descriptor);
return(descriptor.CreateDefinition());
}
return(Definition);
}
finally
{
_configure = null;
}
}
private IfBuilder GenerateComplexDataInterfaceIfClause(
ObjectTypeDescriptor objectTypeDescriptor,
string variableName)
{
var ifCorrectType = IfBuilder.New();
var matchedTypeName = GetParameterName(objectTypeDescriptor.Name);
// since we want to create the data name we will need to craft the type name
// by hand by using the GraphQL type name and the state namespace.
// TODO : state namespace should be available here!
var dataTypeName = new RuntimeTypeInfo(
CreateDataTypeName(objectTypeDescriptor.Name),
$"{objectTypeDescriptor.RuntimeType.Namespace}.State");
ifCorrectType.SetCondition(
$"{_dataParameterName} is {dataTypeName} {matchedTypeName}");
var constructorCall = MethodCallBuilder.New()
.SetPrefix($"{variableName} = new ")
.SetMethodName(objectTypeDescriptor.RuntimeType.ToString());
foreach (PropertyDescriptor prop in objectTypeDescriptor.Properties)
{
var propAccess = $"{matchedTypeName}.{prop.Name}";
if (prop.Type.IsEntityType())
{
constructorCall.AddArgument(
BuildMapMethodCall(
matchedTypeName,
prop));
}
else
{
constructorCall.AddArgument(propAccess);
}
}
return(ifCorrectType.AddCode(constructorCall));
}
private IfBuilder GenerateComplexDataInterfaceIfClause(
ObjectTypeDescriptor objectTypeDescriptor,
string variableName)
{
var matchedTypeName = GetParameterName(objectTypeDescriptor.Name);
// since we want to create the data name we will need to craft the type name
// by hand by using the GraphQL type name and the state namespace.
var dataTypeName = new RuntimeTypeInfo(
CreateDataTypeName(objectTypeDescriptor.Name),
$"{objectTypeDescriptor.RuntimeType.Namespace}.State");
MethodCallBuilder constructorCall = MethodCallBuilder
.Inline()
.SetNew()
.SetMethodName(objectTypeDescriptor.RuntimeType.ToString());
foreach (PropertyDescriptor prop in objectTypeDescriptor.Properties)
{
if (prop.Type.IsEntityType())
{
constructorCall.AddArgument(BuildMapMethodCall(matchedTypeName, prop));
}
else
{
constructorCall.AddArgument($"{matchedTypeName}.{prop.Name}");
}
}
return(IfBuilder
.New()
.SetCondition($"{_dataParameterName} is {dataTypeName} {matchedTypeName}")
.AddCode(
AssignmentBuilder
.New()
.SetLefthandSide(variableName)
.SetRighthandSide(constructorCall)));
}
protected override ObjectTypeDescriptor <dynamic, dynamic> Mapping <T>(ObjectTypeDescriptor <dynamic, dynamic> o)
{
return(o
.Properties(osp => osp
.Keyword(ky =>
{
ky
.Name(NodeNames.Value)
.Normalizer("lowercase")
.Fields(ff => ff
.DmpStandardEnglishAnalyzer()
.DmpNgramAnalyzer()
);
if (typeof(T) != typeof(LinkedTypesOptions))
{
ky.CopyTo(ct => ct.Fields(Strings.DidYouMeanTrigram));
}
return ky;
})
));
}
private IfBuilder CreateUpdateEntityStatement(
ObjectTypeDescriptor concreteType)
{
IfBuilder ifStatement = IfBuilder
.New()
.SetCondition(
MethodCallBuilder
.Inline()
.SetMethodName(_entityId, "Name", nameof(string.Equals))
.AddArgument(concreteType.Name.AsStringToken())
.AddArgument(TypeNames.OrdinalStringComparison));
RuntimeTypeInfo entityTypeName = CreateEntityType(
concreteType.Name,
concreteType.RuntimeType.NamespaceWithoutGlobal);
IfBuilder ifBuilder = BuildTryGetEntityIf(entityTypeName)
.AddCode(CreateEntityConstructorCall(concreteType, false))
.AddElse(CreateEntityConstructorCall(concreteType, true));
return(ifStatement
.AddCode(ifBuilder)
.AddEmptyLine());
}
public void ProcessMetadataLog(ByteBuffer buffer)
{
var reader = new ByteBufferReader(buffer);
var typeId = reader.ReadVInt32();
while (typeId != 0)
{
var typeCategory = (TypeCategory)reader.ReadUInt8();
ITypeDescriptor descriptor;
switch (typeCategory)
{
case TypeCategory.BuildIn:
throw new ArgumentOutOfRangeException();
case TypeCategory.Class:
descriptor = new ObjectTypeDescriptor(this, reader, NestedDescriptorReader);
break;
case TypeCategory.List:
descriptor = new ListTypeDescriptor(this, reader, NestedDescriptorReader);
break;
case TypeCategory.Dictionary:
descriptor = new DictionaryTypeDescriptor(this, reader, NestedDescriptorReader);
break;
case TypeCategory.Enum:
descriptor = new EnumTypeDescriptor(this, reader);
break;
case TypeCategory.Nullable:
descriptor = new NullableTypeDescriptor(this, reader, NestedDescriptorReader);
break;
default:
throw new ArgumentOutOfRangeException();
}
while (-typeId - 1 >= _id2InfoNew.Count)
{
_id2InfoNew.Add(null);
}
if (_id2InfoNew[-typeId - 1] == null)
{
_id2InfoNew[-typeId - 1] = new DeserializerTypeInfo {
Id = typeId, Descriptor = descriptor
}
}
;
typeId = reader.ReadVInt32();
}
for (var i = 0; i < _id2InfoNew.Count; i++)
{
_id2InfoNew[i].Descriptor.MapNestedTypes(d =>
{
var placeHolderDescriptor = d as PlaceHolderDescriptor;
return(placeHolderDescriptor != null ? _id2InfoNew[-placeHolderDescriptor.TypeId - 1].Descriptor : d);
});
}
// This additional cycle is needed to fill names of recursive structures
for (var i = 0; i < _id2InfoNew.Count; i++)
{
_id2InfoNew[i].Descriptor.MapNestedTypes(d => d);
}
for (var i = 0; i < _id2InfoNew.Count; i++)
{
var infoForType = _id2InfoNew[i];
for (var j = ReservedBuildinTypes; j < _id2Info.Count; j++)
{
if (infoForType.Descriptor.Equals(_id2Info[j].Descriptor))
{
_remapToOld[infoForType.Descriptor] = _id2Info[j].Descriptor;
_id2InfoNew[i] = _id2Info[j];
infoForType = _id2InfoNew[i];
break;
}
}
if (infoForType.Id < 0)
{
infoForType.Id = _id2Info.Count;
_id2Info.Add(infoForType);
_typeOrDescriptor2Info[infoForType.Descriptor] = infoForType;
}
}
for (var i = 0; i < _id2InfoNew.Count; i++)
{
_id2InfoNew[i].Descriptor.MapNestedTypes(d =>
{
ITypeDescriptor res;
return(_remapToOld.TryGetValue(d, out res) ? res : d);
});
}
_id2InfoNew.Clear();
_remapToOld.Clear();
}
Func <AbstractBufferedReader, ITypeBinaryDeserializerContext, ITypeDescriptor, object> LoaderFactory(ITypeDescriptor descriptor)
{
var loadAsType = LoadAsType(descriptor);
var methodBuilder = ILBuilder.Instance.NewMethod <Func <AbstractBufferedReader, ITypeBinaryDeserializerContext, ITypeDescriptor, object> >("DeserializerFor" + descriptor.Name);
var il = methodBuilder.Generator;
descriptor.GenerateLoad(il, ilGen => ilGen.Ldarg(0), ilGen => ilGen.Ldarg(1), ilGen => ilGen.Ldarg(2), loadAsType);
if (loadAsType.IsValueType)
{
il.Box(loadAsType);
}
else if (loadAsType != typeof(object))
{
il.Castclass(typeof(object));
}
il.Ret();
return(methodBuilder.Create());
}
public ITypeDescriptor Create(Type type)
{
if (_typeOrDescriptor2Info.TryGetValue(type, out var result))
{
return(result.Descriptor);
}
if (_typeOrDescriptor2InfoNew.TryGetValue(type, out result))
{
return(result.Descriptor);
}
ITypeDescriptor desc = null;
Type typeAlternative = null;
if (!type.IsSubclassOf(typeof(Delegate)))
{
if (type.IsGenericType)
{
typeAlternative = type.SpecializationOf(typeof(IList <>));
if (typeAlternative != null)
{
if (type != typeAlternative)
{
if (_typeOrDescriptor2Info.TryGetValue(typeAlternative, out result))
{
_typeOrDescriptor2Info[type] = result;
return(result.Descriptor);
}
if (_typeOrDescriptor2InfoNew.TryGetValue(typeAlternative, out result))
{
_typeOrDescriptor2InfoNew[type] = result;
return(result.Descriptor);
}
}
desc = new ListTypeDescriptor(this, typeAlternative);
}
else
{
typeAlternative = type.SpecializationOf(typeof(IDictionary <,>));
if (typeAlternative != null)
{
if (type != typeAlternative)
{
if (_typeOrDescriptor2Info.TryGetValue(typeAlternative, out result))
{
_typeOrDescriptor2Info[type] = result;
return(result.Descriptor);
}
if (_typeOrDescriptor2InfoNew.TryGetValue(typeAlternative, out result))
{
_typeOrDescriptor2InfoNew[type] = result;
return(result.Descriptor);
}
}
desc = new DictionaryTypeDescriptor(this, typeAlternative);
}
else if (type.GetGenericTypeDefinition().InheritsOrImplements(typeof(IIndirect <>)))
{
return(null);
}
else if (type.GetGenericTypeDefinition() == typeof(Nullable <>))
{
typeAlternative = type.SpecializationOf(typeof(Nullable <>));
if (typeAlternative != null)
{
if (type != typeAlternative)
{
if (_typeOrDescriptor2Info.TryGetValue(typeAlternative, out result))
{
_typeOrDescriptor2Info[type] = result;
return(result.Descriptor);
}
if (_typeOrDescriptor2InfoNew.TryGetValue(typeAlternative, out result))
{
_typeOrDescriptor2InfoNew[type] = result;
return(result.Descriptor);
}
}
desc = new NullableTypeDescriptor(this, typeAlternative);
}
}
}
}
else if (type.IsArray)
{
typeAlternative = type.SpecializationOf(typeof(IList <>));
Debug.Assert(typeAlternative != null && type != typeAlternative);
if (_typeOrDescriptor2Info.TryGetValue(typeAlternative, out result))
{
_typeOrDescriptor2Info[type] = result;
return(result.Descriptor);
}
if (_typeOrDescriptor2InfoNew.TryGetValue(typeAlternative, out result))
{
_typeOrDescriptor2InfoNew[type] = result;
return(result.Descriptor);
}
desc = new ListTypeDescriptor(this, typeAlternative);
}
else if (type.IsEnum)
{
desc = new EnumTypeDescriptor(this, type);
}
else if (type.IsValueType)
{
throw new BTDBException($"Unsupported value type {type.Name}.");
}
else
{
desc = new ObjectTypeDescriptor(this, type);
}
}
if (desc == null)
{
throw new BTDBException("Don't know how to serialize type " + type.ToSimpleName());
}
result = new SerializerTypeInfo
{
Id = 0,
Descriptor = desc
};
_typeOrDescriptor2InfoNew[desc] = result;
_typeOrDescriptor2InfoNew[type] = result;
if (typeAlternative != null)
{
_typeOrDescriptor2InfoNew[typeAlternative] = result;
}
if (!desc.FinishBuildFromType(this))
{
_typeOrDescriptor2InfoNew.Remove(desc);
_typeOrDescriptor2InfoNew.Remove(type);
if (typeAlternative != null)
{
_typeOrDescriptor2InfoNew.Remove(typeAlternative);
}
return(null);
}
return(desc);
}
public void ProcessMetadataLog(ByteBuffer buffer)
{
var reader = new ByteBufferReader(buffer);
var typeId = reader.ReadVInt32();
while (typeId != 0)
{
var typeCategory = (TypeCategory)reader.ReadUInt8();
ITypeDescriptor descriptor;
switch (typeCategory)
{
case TypeCategory.BuildIn:
throw new ArgumentOutOfRangeException();
case TypeCategory.Class:
descriptor = new ObjectTypeDescriptor(this, reader, NestedDescriptorReader);
break;
case TypeCategory.List:
descriptor = new ListTypeDescriptor(this, reader, NestedDescriptorReader);
break;
case TypeCategory.Dictionary:
descriptor = new DictionaryTypeDescriptor(this, reader, NestedDescriptorReader);
break;
case TypeCategory.Enum:
descriptor = new EnumTypeDescriptor(this, reader);
break;
case TypeCategory.Nullable:
descriptor = new NullableTypeDescriptor(this, reader, NestedDescriptorReader);
break;
default:
throw new ArgumentOutOfRangeException();
}
while (-typeId - 1 >= _id2InfoNew.Count)
{
_id2InfoNew.Add(null);
}
if (_id2InfoNew[-typeId - 1] == null)
{
_id2InfoNew[-typeId - 1] = new SerializerTypeInfo {
Id = typeId, Descriptor = descriptor
}
}
;
typeId = reader.ReadVInt32();
}
for (var i = 0; i < _id2InfoNew.Count; i++)
{
_id2InfoNew[i] !.Descriptor.MapNestedTypes(d =>
{
var placeHolderDescriptor = d as PlaceHolderDescriptor;
return(placeHolderDescriptor != null
? _id2InfoNew[-placeHolderDescriptor.TypeId - 1] !.Descriptor
: d);
});
}
// This additional cycle is needed to fill names of recursive structures
for (var i = 0; i < _id2InfoNew.Count; i++)
{
_id2InfoNew[i] !.Descriptor.MapNestedTypes(d => d);
}
for (var i = 0; i < _id2InfoNew.Count; i++)
{
var infoForType = _id2InfoNew[i] !;
for (var j = ReservedBuildinTypes; j < _id2Info.Count; j++)
{
if (infoForType.Descriptor.Equals(_id2Info[j].Descriptor))
{
_remapToOld[infoForType.Descriptor] = _id2Info[j].Descriptor;
_id2InfoNew[i] = _id2Info[j];
infoForType = _id2InfoNew[i];
break;
}
}
if (infoForType.Id < 0)
{
infoForType.Id = _id2Info.Count;
_id2Info.Add(infoForType);
_typeOrDescriptor2Info[infoForType.Descriptor] = infoForType;
}
}
for (var i = 0; i < _id2InfoNew.Count; i++)
{
_id2InfoNew[i] !.Descriptor.MapNestedTypes(d =>
{
ITypeDescriptor res;
return(_remapToOld.TryGetValue(d, out res) ? res : d);
});
}
_id2InfoNew.Clear();
_remapToOld.Clear();
}
public static ObjectTypeDescriptor <dynamic, dynamic> Outbound(this ObjectTypeDescriptor <dynamic, dynamic> otb)
{
return(otb.Name(NodeNames.Outbound));
}
protected abstract ObjectTypeDescriptor <dynamic, dynamic> Mapping <T>(ObjectTypeDescriptor <dynamic, dynamic> o) where T : IOptions;
public static ObjectTypeDescriptor ToDescriptor(
this ObjectTypeDefinition definition,
IDescriptorContext context)
=> ObjectTypeDescriptor.From(context, definition);
