public void should_map_interfaces_when_no_factory_supplied()
{
IDataReader reader = GetDataReader();
Mock
.Arrange(() => reader.FieldCount)
.Returns(1);
Mock
.Arrange(() => reader.GetName(0))
.Returns("name");
Mock
.Arrange(() => reader.GetOrdinal("name"))
.Returns(0);
Mock
.Arrange(() => reader.GetString(0))
.Returns("nohros");
var mapper =
new DataReaderMapperBuilder <ISimpleType>(
"should_map_interfaces_when_no_factory_supplied")
.Map(x => x.Name, "name")
.Build();
ISimpleType obj = mapper.Map(reader);
Assert.That(obj.Name, Is.EqualTo("nohros"));
}
public void TestCreate()
{
ISimpleType <Value> ValueType = Types.Literal(Value.None);
var value = ValueType.Create();
Assert.Equal(Value.None, value);
}
// This returns true if a property can be represented by a string
public static bool IsTextProperty(IPropertyDefinition propertyDefinition)
{
ISimpleType dataType =
propertyDefinition.PropertyType as ISimpleType;
if (dataType != null)
{
Type clrType = GetBaseSystemType(dataType);
return(clrType != null &&
!object.ReferenceEquals(clrType, typeof(byte[])));
}
return(false);
}
/// <summary>
/// Checks if a node source is ready.
/// </summary>
/// <param name="node">The node for which the value is checked.</param>
/// <param name="data">Optional data returned to the caller.</param>
public override bool IsReady(TSource node, out object data)
{
data = null;
bool Result = false;
ISimpleType SimpleType = node as ISimpleType;
Debug.Assert(SimpleType != null);
Result = IsTypeReady(SimpleType, out data);
return(Result);
}
/// <summary>
/// Applies the rule.
/// </summary>
/// <param name="node">The node instance to modify.</param>
/// <param name="data">Private data from CheckConsistency().</param>
public override void Apply(ISimpleType node, object data)
{
ITypeName ValidTypeName = ((Tuple <ITypeName, ICompiledType>)data).Item1;
ICompiledType ValidType = ((Tuple <ITypeName, ICompiledType>)data).Item2;
node.TypeNameSource.Item = ValidTypeName;
node.TypeSource.Item = ValidType;
node.ValidTypeSource.Item = "Set";
IIdentifier ClassIdentifier = (IIdentifier)node.ClassIdentifier;
string ValidIdentifier = ClassIdentifier.ValidText.Item;
IClass EmbeddingClass = node.EmbeddingClass;
ISealableDictionary <string, ICompiledType> LocalGenericTable = EmbeddingClass.LocalGenericTable;
if (LocalGenericTable.ContainsKey(ValidIdentifier))
{
IFormalGenericType FormalGeneric = (IFormalGenericType)LocalGenericTable[ValidIdentifier];
node.FormalGenericSource.Item = FormalGeneric;
node.FormalGenericNameSource.Item = FormalGeneric.ResolvedTypeName;
}
}
/// <summary>
/// Checks for errors before applying a rule.
/// </summary>
/// <param name="node">The node instance to check.</param>
/// <param name="dataList">Optional data collected during inspection of sources.</param>
/// <param name="data">Private data to give to Apply() upon return.</param>
/// <returns>True if an error occured.</returns>
public override bool CheckConsistency(ISimpleType node, IDictionary <ISourceTemplate, object> dataList, out object data)
{
bool Success = true;
data = null;
IIdentifier ClassIdentifier = (IIdentifier)node.ClassIdentifier;
Debug.Assert(ClassIdentifier.ValidText.IsAssigned);
string ValidIdentifier = ClassIdentifier.ValidText.Item;
Debug.Assert(SourceTemplateList.Count > 0);
IOnceReferenceTypeSourceTemplate TypeSourceTemplate = SourceTemplateList[0] as IOnceReferenceTypeSourceTemplate;
Debug.Assert(dataList.ContainsKey(TypeSourceTemplate));
Tuple <ITypeName, ICompiledType, IError> TypeSourceData = dataList[TypeSourceTemplate] as Tuple <ITypeName, ICompiledType, IError>;
ITypeName ValidTypeName = TypeSourceData.Item1;
ICompiledType ValidType = TypeSourceData.Item2;
IError Error = TypeSourceData.Item3;
if (Error != null)
{
Debug.Assert(ValidTypeName == null);
Debug.Assert(ValidType == null);
AddSourceError(Error);
Success = false;
}
else
{
Debug.Assert(ValidTypeName != null);
Debug.Assert(ValidType != null);
data = new Tuple <ITypeName, ICompiledType>(ValidTypeName, ValidType);
}
return(Success);
}
// This returns the underlying type of a business type
public static Type GetBaseSystemType(ISimpleType dataType)
{
while (dataType != null)
{
if (dataType is IPrimitiveType)
{
// Primitive types are foundation LightSwitch data types like:
// String/Int32/Decimal/Date/...
return(((IPrimitiveType)dataType).ClrType);
}
else if (dataType is INullableType)
{
// NullableType represents a Nullable version of
// any primitive or semantic (business) type.
dataType = ((INullableType)dataType).UnderlyingType;
}
else if (dataType is ISemanticType)
{
dataType = ((ISemanticType)dataType).UnderlyingType;
}
}
return(null);
}
public static IType <Nullable <T>, Nullable <T> > Maybe <T>(ISimpleType <T> type) where T : struct
{
return(Union <Nullable <T>, Nullable <T> >(OptionalNull, type));
}
private void CreateFormat(string formatString, string name, string sampleInput, string sampleOut, ISimpleType type, string memo)
{
var fs = ObjectSpace.FindObject <IDisplayFormatSolution>(new BinaryOperator("FormatString", formatString));
if (fs == null)
{
fs = ObjectSpace.CreateObject <IDisplayFormatSolution>();
fs.FormatString = formatString;
fs.Name = name;
fs.SampleInput = sampleInput;
fs.SampleOut = sampleOut;
fs.Type = type;
fs.Memo = memo;
}
var em = ObjectSpace.FindObject <IEditFormatSolution>(new BinaryOperator("FormatString", formatString));
if (em == null)
{
em = ObjectSpace.CreateObject <IEditFormatSolution>();
em.FormatString = formatString;
em.Name = name;
em.SampleInput = sampleInput;
em.SampleOut = sampleOut;
em.Type = type;
em.Memo = memo;
}
}
private bool IsTypeReady(ISimpleType node, out object data)
{
data = null;
bool IsReady = true;
ITypeName ValidTypeName = null;
ICompiledType ValidType = null;
IError Error = null;
IClass EmbeddingClass = node.EmbeddingClass;
IFeature EmbeddingFeature = node.EmbeddingFeature;
IIdentifier ClassIdentifier = (IIdentifier)node.ClassIdentifier;
Debug.Assert(ClassIdentifier.ValidText.IsAssigned);
string ValidIdentifier = ClassIdentifier.ValidText.Item;
ISealableDictionary <string, IImportedClass> ImportedClassTable = EmbeddingClass.ImportedClassTable;
ISealableDictionary <string, ICompiledType> LocalGenericTable = EmbeddingClass.LocalGenericTable;
ISealableDictionary <IFeatureName, ISealableDictionary <string, IClass> > LocalExportTable = EmbeddingClass.LocalExportTable;
ISealableDictionary <IFeatureName, ITypedefType> LocalTypedefTable = EmbeddingClass.LocalTypedefTable;
ISealableDictionary <IFeatureName, IDiscrete> LocalDiscreteTable = EmbeddingClass.LocalDiscreteTable;
ISealableDictionary <IFeatureName, IFeatureInstance> LocalFeatureTable = EmbeddingClass.LocalFeatureTable;
IsReady &= ImportedClassTable.IsSealed;
IsReady &= LocalGenericTable.IsSealed;
IsReady &= LocalExportTable.IsSealed;
IsReady &= LocalTypedefTable.IsSealed;
IsReady &= LocalDiscreteTable.IsSealed;
IsReady &= LocalFeatureTable.IsSealed;
IsReady &= EmbeddingClass.ResolvedClassType.IsAssigned;
if (IsReady)
{
if (ValidIdentifier.ToUpperInvariant() == LanguageClasses.Any.Name.ToUpperInvariant())
{
GetBaseClassType(Class.ClassAny, out ValidTypeName, out ValidType);
}
else if (ValidIdentifier.ToUpperInvariant() == LanguageClasses.AnyReference.Name.ToUpperInvariant())
{
GetBaseClassType(Class.ClassAnyReference, out ValidTypeName, out ValidType);
}
else if (ValidIdentifier.ToUpperInvariant() == LanguageClasses.AnyValue.Name.ToUpperInvariant())
{
GetBaseClassType(Class.ClassAnyValue, out ValidTypeName, out ValidType);
}
else if (ImportedClassTable.ContainsKey(ValidIdentifier))
{
IImportedClass Imported = ImportedClassTable[ValidIdentifier];
IClass BaseClass = Imported.Item;
IsReady = CheckValidityAsClass(BaseClass, out ValidTypeName, out ValidType, out bool IsInvalidGeneric);
if (IsInvalidGeneric)
{
Error = new ErrorGenericClass(ClassIdentifier, ValidIdentifier);
}
}
else if (LocalGenericTable.ContainsKey(ValidIdentifier))
{
IFormalGenericType FormalGeneric = (IFormalGenericType)LocalGenericTable[ValidIdentifier];
GetGenericType(FormalGeneric, out ValidTypeName, out ValidType);
}
else if (FeatureName.TableContain(LocalTypedefTable, ValidIdentifier, out IFeatureName Key, out ITypedefType DefinedType))
{
IsReady = CheckValidityAsTypedef(DefinedType, out ValidTypeName, out ValidType);
}
else
{
Error = new ErrorUnknownIdentifier(ClassIdentifier, ValidIdentifier);
}
}
