private void PopulatePropertiesFromPaths(ComplexInstance instance, IEnumerable <MemberProperty> properties, string propertyPath, IEnumerable <NamedValue> namedValues)
{
ExceptionUtilities.CheckArgumentNotNull(instance, "instance");
ExceptionUtilities.CheckArgumentNotNull(properties, "properties");
ExceptionUtilities.CheckArgumentNotNull(namedValues, "namedValues");
foreach (MemberProperty property in properties)
{
string childPropertyPath = property.Name;
if (propertyPath != null)
{
childPropertyPath = propertyPath + "." + property.Name;
}
CollectionDataType collectionDataType = property.PropertyType as CollectionDataType;
PrimitiveDataType primitiveDataType = property.PropertyType as PrimitiveDataType;
if (primitiveDataType != null)
{
NamedValue memberPropertyNamedValue = namedValues.SingleOrDefault(nv => nv.Name == childPropertyPath);
if (memberPropertyNamedValue != null)
{
instance.Add(this.PrimitiveProperty(property, memberPropertyNamedValue.Value));
}
}
else if (collectionDataType != null)
{
IEnumerable <NamedValue> bagNamedValues = namedValues.Where(nv => nv.Name.StartsWith(childPropertyPath + ".", StringComparison.Ordinal)).ToList();
if (bagNamedValues.Count() > 0)
{
this.PopulateMultiValuePropertyFromPaths(instance, property, collectionDataType.ElementDataType, childPropertyPath, bagNamedValues);
}
else
{
this.PopulateCollectionPropertyWithNullOrEmpty(instance, property, childPropertyPath, namedValues);
}
}
else
{
var complexDataType = property.PropertyType as ComplexDataType;
ExceptionUtilities.CheckObjectNotNull(complexDataType, "Property '{0}' was not primitive, a collection, or complex", property.Name);
IEnumerable <NamedValue> complexInstanceNamedValues = namedValues.Where(nv => nv.Name.StartsWith(childPropertyPath + ".", StringComparison.Ordinal)).ToList();
if (complexInstanceNamedValues.Count() > 0)
{
PropertyInstance memberPropertyInstance = this.ComplexProperty(property, childPropertyPath, complexInstanceNamedValues);
instance.Add(memberPropertyInstance);
}
else
{
// Check for null case
IEnumerable <NamedValue> exactMatches = namedValues.Where(nv => nv.Name == childPropertyPath).ToList();
ExceptionUtilities.Assert(exactMatches.Count() < 2, "Should only find at most one property path {0} when looking for null value", childPropertyPath);
if (exactMatches.Count() == 1)
{
instance.Add(new ComplexProperty(property.Name, new ComplexInstance(complexDataType.Definition.FullName, true)));
}
}
}
}
}
IEdmTypeReference IDataTypeVisitor <IEdmTypeReference> .Visit(CollectionDataType dataType)
{
var elementTypeReference = this.ConvertToEdmTypeReference(dataType.ElementDataType);
return(elementTypeReference.ToCollectionTypeReference()
.Nullable(dataType.IsNullable));
}
/// <summary>
/// Determines whether an entity set is expected to be returned from a function call
/// </summary>
/// <param name="function">the function being called</param>
/// <param name="previousEntitySet">the binding entity set</param>
/// <param name="returningEntitySet">the expected entity set, if appropriate</param>
/// <returns>whether or not an entity set is expected</returns>
public static bool TryGetExpectedActionEntitySet(this Function function, EntitySet previousEntitySet, out EntitySet returningEntitySet)
{
ExceptionUtilities.CheckArgumentNotNull(function, "function");
ServiceOperationAnnotation serviceOperationAnnotation = function.Annotations.OfType <ServiceOperationAnnotation>().Single();
EntityDataType entityDataType = function.ReturnType as EntityDataType;
CollectionDataType collectionDataType = function.ReturnType as CollectionDataType;
if (collectionDataType != null)
{
entityDataType = collectionDataType.ElementDataType as EntityDataType;
}
if (entityDataType != null)
{
if (serviceOperationAnnotation.EntitySetPath == null)
{
returningEntitySet = function.Model.GetDefaultEntityContainer().EntitySets.Single(es => es.EntityType == entityDataType.Definition);
}
else
{
string navigationPropertyName = serviceOperationAnnotation.EntitySetPath.Substring(serviceOperationAnnotation.EntitySetPath.LastIndexOf('/') + 1);
NavigationProperty navigationProperty = previousEntitySet.EntityType.AllNavigationProperties.Single(np => np.Name == navigationPropertyName);
var associationSets = function.Model.GetDefaultEntityContainer().AssociationSets.Where(a => a.AssociationType == navigationProperty.Association);
AssociationSet associationSet = associationSets.Single(a => a.Ends.Any(e => e.EntitySet == previousEntitySet));
returningEntitySet = associationSet.Ends.Single(es => es.EntitySet != previousEntitySet).EntitySet;
}
return(true);
}
returningEntitySet = null;
return(false);
}
private IDataGenerator GetPropertyDataGenerator(MemberProperty property, bool isUnique)
{
if (property.PropertyType == null)
{
throw new TaupoInvalidOperationException(
string.Format(CultureInfo.InvariantCulture, "Cannot create data generator for the property '{0}' because it's type is null.", property.Name));
}
// First check if custom data generator has been specified for this property and use it.
var customDataGen = property.Annotations.OfType <DataGeneratorAnnotation>().SingleOrDefault();
if (customDataGen != null)
{
return(customDataGen.DataGenerator);
}
// If there is no custom data generator create data generator based on data generation hints.
List <DataGenerationHint> dataGenHints = property.Annotations.OfType <DataGenerationHintsAnnotation>().SelectMany(a => a.Hints).ToList();
CollectionDataType collectionDataType = property.PropertyType as CollectionDataType;
if (collectionDataType != null)
{
return(this.ResolveCollectionDataGenerator(collectionDataType, dataGenHints));
}
else
{
return(this.ResolveNonCollectionDataGenerator(property.PropertyType, property.IsPrimaryKey || isUnique, dataGenHints));
}
}
private IDataGenerator ResolveCollectionDataGenerator(CollectionDataType collectionType, IList <DataGenerationHint> dataGenHints)
{
IDataGenerator elementDataGenerator = this.ResolveNonCollectionDataGenerator(collectionType.ElementDataType, false, dataGenHints);
int minCount = dataGenHints.Max <CollectionMinCountHint, int>(0);
int maxCount = dataGenHints.Min <CollectionMaxCountHint, int>(Math.Max(minCount, 10));
return(new CollectionStructuralDataGenerator(elementDataGenerator, this.Random, minCount, maxCount));
}
private static void CachePropertiesValues(List <NamedValue> list, string path, string structuralTypeFullName, IEnumerable <MemberProperty> properties, object obj, IEntityModelObjectServices objectServices)
{
var adapter = objectServices.GetObjectAdapter(structuralTypeFullName);
foreach (MemberProperty property in properties.Where(p => !(p.PropertyType is StreamDataType)))
{
object value = adapter.GetMemberValue <object>(obj, property.Name);
ComplexDataType complexDataType = property.PropertyType as ComplexDataType;
CollectionDataType collectionDataType = property.PropertyType as CollectionDataType;
if (collectionDataType != null && value != null)
{
var complexElementDataType = collectionDataType.ElementDataType as ComplexDataType;
IEnumerable enumerable = value as IEnumerable;
ExceptionUtilities.CheckObjectNotNull(enumerable, "Property type is a collection but does not implement IEnumerable. Property path: '{0}'.", path + property.Name);
int count = 0;
foreach (var collectionElement in enumerable)
{
string currentPath = path + property.Name + "." + count;
if (complexElementDataType == null || collectionElement == null)
{
list.Add(new NamedValue(currentPath, collectionElement));
}
else
{
CachePropertiesValues(
list,
currentPath + ".",
complexElementDataType.Definition.FullName,
complexElementDataType.Definition.Properties,
collectionElement,
objectServices);
}
count++;
}
if (count == 0)
{
list.Add(new NamedValue(path + property.Name, EmptyData.Value));
}
}
else if (value == null || complexDataType == null)
{
list.Add(new NamedValue(path + property.Name, value));
}
else
{
CachePropertiesValues(list, path + property.Name + ".", complexDataType.Definition.FullName, complexDataType.Definition.Properties, value, objectServices);
}
}
}
/// <summary>
/// Resolves enum definitions in enum data types
/// </summary>
/// <param name="dataType">the data type</param>
/// <returns>Resolved data type</returns>
public DataType Visit(CollectionDataType dataType)
{
var resolvedElementDataType = this.ResolveDataType(dataType.ElementDataType);
if (resolvedElementDataType != dataType.ElementDataType)
{
return(dataType.WithElementDataType(resolvedElementDataType));
}
return(dataType);
}
private IEnumerable <XObject> GenerateCollection(CollectionDataType collectionDataType)
{
var elementDataType = collectionDataType.ElementDataType;
var result = new List <XObject>();
result.Add(this.GenerateTypeAttribute(collectionDataType));
result.Add(this.GenerateNullableAttribute(elementDataType));
result.AddRange(this.GenerateTypeFacets(elementDataType).Cast <XObject>());
return(result);
}
static SpriteCollectionData GetCollectionData(UnityEngine.Object spriteCollectionData)
{
var rawSprites = GetSpriteDefinitionsRaw(spriteCollectionData);
SpriteCollectionData data = new SpriteCollectionData();
data.CollectionName = (string)CollectionDataType.GetField("spriteCollectionName").GetValue(spriteCollectionData);
data.MainTexture = (Texture)((Array)CollectionDataType.GetField("textures").GetValue(spriteCollectionData)).GetValue(0);
data.GUID = (string)CollectionDataType.GetField("spriteCollectionName").GetValue(spriteCollectionData);
data.TextureFilterMode = (FilterMode)CollectionDataType.GetField("textureFilterMode").GetValue(spriteCollectionData);
data.Version = (int)CollectionDataType.GetField("version").GetValue(spriteCollectionData);
data.Definitions = new SpriteDefinitionData[rawSprites.GetLength(0)];
Debug.Log("Collection Name = " + data.CollectionName);
Debug.Log("Sprite Count = " + rawSprites.GetLength(0));
for (int i = 0; i < rawSprites.GetLength(0); i++)
{
var rawSprite = rawSprites.GetValue(i);
var definition = new SpriteDefinitionData();
definition.Name = (string)SpriteDefinitionType.GetField("name").GetValue(rawSprite) ?? ("unknown_" + i.ToString());
Debug.Log("Sprite = " + definition.Name);
Debug.Log("Sprite ID = " + i);
var oldPositions = (Vector3[])SpriteDefinitionType.GetField("positions").GetValue(rawSprite);
var newPositions = new Vector2[oldPositions.GetLength(0)];
for (int j = 0; j < oldPositions.GetLength(0); j++)
{
newPositions[j] = oldPositions[j];
}
definition.Positions = newPositions;
definition.TextureSize = (Vector2)SpriteDefinitionType.GetField("texelSize").GetValue(rawSprite);
definition.UVs = (Vector2[])SpriteDefinitionType.GetField("uvs").GetValue(rawSprite);
var flippedEnum = SpriteDefinitionType.GetField("flipped").GetValue(rawSprite);
var enumType = flippedEnum.GetType();
definition.Flipped = Enum.GetName(enumType, flippedEnum) == "Tk2d";
data.Definitions[i] = definition;
}
return(data);
}
private XElement GenerateCollectionElementInFunction(CollectionDataType collection, XNamespace xmlNamespace)
{
var elementDataType = collection.ElementDataType;
if (this.IsNominalType(elementDataType))
{
return(new XElement(
xmlNamespace + "CollectionType",
new XAttribute("ElementType", this.GetDataTypeName(elementDataType)),
this.GenerateNullableAttributeInFunction(elementDataType),
this.GenerateTypeFacets(elementDataType)));
}
else
{
return(new XElement(
xmlNamespace + "CollectionType",
this.GenerateTypeElementInFunction(elementDataType, xmlNamespace)));
}
}
/// <summary>
/// Initializes static members of the DataTypes class.
/// </summary>
static DataTypes()
{
Integer = new IntegerDataType();
Stream = new StreamDataType();
String = new StringDataType();
Boolean = new BooleanDataType();
FixedPoint = new FixedPointDataType();
FloatingPoint = new FloatingPointDataType();
DateTime = new DateTimeDataType();
Binary = new BinaryDataType();
Guid = new GuidDataType();
TimeOfDay = new TimeOfDayDataType();
ComplexType = new ComplexDataType();
EntityType = new EntityDataType();
CollectionType = new CollectionDataType();
ReferenceType = new ReferenceDataType();
RowType = new RowDataType();
EnumType = new EnumDataType();
Spatial = new SpatialDataType();
}
/// <summary>
/// Generates property data type information
/// </summary>
/// <param name="memberProperty">The property.</param>
/// <param name="xmlNamespace">The xml namespace.</param>
/// <returns>XElements and XAttributes for the data type.</returns>
public IEnumerable <XObject> GeneratePropertyType(MemberProperty memberProperty, XNamespace xmlNamespace)
{
List <XObject> result = new List <XObject>();
if (memberProperty.PropertyType != null)
{
CollectionDataType collectionDataType = memberProperty.PropertyType as CollectionDataType;
if (collectionDataType != null)
{
result.AddRange(this.GenerateCollection(collectionDataType));
}
else
{
result.Add(this.GenerateTypeAttribute(memberProperty.PropertyType));
result.Add(this.GenerateNullableAttribute(memberProperty.PropertyType));
result.AddRange(this.GenerateTypeFacets(memberProperty.PropertyType).Cast <XObject>());
}
}
return(result);
}
private void CompareMemberPropertyDatatype(string memberName, DataType expectedDataType, DataType actualDataType)
{
PrimitiveDataType expectedPrimitiveDataType = expectedDataType as PrimitiveDataType;
ComplexDataType expectedComplexDataType = expectedDataType as ComplexDataType;
CollectionDataType expectedCollectionDataType = expectedDataType as CollectionDataType;
SpatialDataType expectedSpatialDataType = expectedDataType as SpatialDataType;
if (expectedPrimitiveDataType != null)
{
PrimitiveDataType actualPrimitiveDataType = actualDataType as PrimitiveDataType;
this.WriteErrorIfFalse(actualPrimitiveDataType != null, "Expected member '{0}' with primitiveDataType '{1}' instead of '{2}'", memberName, expectedPrimitiveDataType, actualDataType);
if (expectedSpatialDataType != null)
{
SpatialDataType actualSpatialDataType = actualDataType as SpatialDataType;
this.CompareSpatialDataType(memberName, expectedSpatialDataType, actualSpatialDataType);
}
}
else if (expectedComplexDataType != null)
{
ComplexDataType actualComplexDataType = actualDataType as ComplexDataType;
if (!this.WriteErrorIfFalse(expectedComplexDataType != null, "Expected member '{0}' with complexDataType '{1}' instead of '{2}'", memberName, expectedComplexDataType, actualDataType))
{
this.WriteErrorIfFalse(expectedComplexDataType.Definition.Name == actualComplexDataType.Definition.Name, "Expected member '{0}' with complexType Name '{1}' not '{2}'", memberName, expectedComplexDataType.Definition.Name, actualComplexDataType.Definition.Name);
}
}
else
{
CollectionDataType actualCollectionDataType = actualDataType as CollectionDataType;
if (!this.WriteErrorIfFalse(expectedCollectionDataType != null, "Expected member '{0}' with collectionType '{1}' instead of '{2}'", memberName, expectedCollectionDataType, actualDataType))
{
this.CompareMemberPropertyDatatype(memberName, expectedCollectionDataType.ElementDataType, actualCollectionDataType.ElementDataType);
}
}
// Complex properties need not be handled specially as they can also have IsNullable = true. The scenario for complex property is given below:
// For reflection and custom: If the DSV <= 2 then it should always contain Nullable=’false’. For DSV >= 3, it should always contain Nullable=’true’
// For EF: For all DSV values it should always contain Nullable=’false’ since complex types are always non-nullable in EF.
this.WriteErrorIfFalse(expectedDataType.IsNullable == actualDataType.IsNullable, "Expected member '{0}' to have an IsNullable of '{1}' instead of '{2}'", memberName, expectedDataType.IsNullable, actualDataType.IsNullable);
}
/// <summary>
/// Visits a collection data type
/// </summary>
/// <param name="dataType">The data type to visit</param>
/// <returns>The backing type for the data type</returns>
public CodeTypeReference Visit(CollectionDataType dataType)
{
throw new TaupoNotSupportedException("Collection backing types cannot be determined without a property");
}
/// <summary>
/// Resolves the specified type into its type reference.
/// </summary>
/// <param name="dataType">The data type.</param>
/// <returns>CodeTypeReference that should be used in code to refer to the type.</returns>
public virtual CodeTypeReference Visit(CollectionDataType dataType)
{
return(Code.GenericType("ICollection", this.Resolve(dataType.ElementDataType)));
}
/// <summary>
/// Visits the specified collection data type.
/// </summary>
/// <param name="dataType">Collection data type.</param>
/// <returns>Implementation-specific value.</returns>
public IList <string> Visit(CollectionDataType dataType)
{
return(emptyList);
}
/// <summary>
/// Visits the specified collection type.
/// </summary>
/// <param name="dataType">Data type.</param>
/// <returns>A clone of the specified <see cref="DataType"/>.</returns>
public DataType Visit(CollectionDataType dataType)
{
return(new CollectionDataType()
.Nullable(dataType.IsNullable)
.WithElementDataType(dataType.ElementDataType.Accept(this)));
}
/// <summary>
/// Resolves the specified entity model schema type and returns the Edm model type for it.
/// </summary>
/// <param name="model">The model to get the type from.</param>
/// <param name="schemaType">The entity model schema type to resolve.</param>
/// <returns>The resolved type for the specified <paramref name="schemaType"/>.</returns>
public static IEdmTypeReference ResolveEntityModelSchemaType(IEdmModel model, DataType schemaType)
{
if (schemaType == null)
{
return(null);
}
PrimitiveDataType primitiveDataType = schemaType as PrimitiveDataType;
if (primitiveDataType != null)
{
return(GetPrimitiveTypeReference(primitiveDataType));
}
if (model == null)
{
return(null);
}
EntityDataType entityDataType = schemaType as EntityDataType;
if (entityDataType != null)
{
IEdmNamedElement edmType = model.FindType(entityDataType.Definition.FullName);
ExceptionUtilities.Assert(
edmType != null,
"The expected entity type '{0}' was not found in the entity model for this test.",
entityDataType.Definition.FullName);
IEdmEntityType entityType = edmType as IEdmEntityType;
ExceptionUtilities.Assert(
entityType != null,
"The expected entity type '{0}' is not defined as entity type in the test's metadata.",
entityDataType.Definition.FullName);
return(entityType.ToTypeReference());
}
ComplexDataType complexDataType = schemaType as ComplexDataType;
if (complexDataType != null)
{
return(GetComplexType(model, complexDataType));
}
CollectionDataType collectionDataType = schemaType as CollectionDataType;
if (collectionDataType != null)
{
DataType collectionElementType = collectionDataType.ElementDataType;
PrimitiveDataType primitiveElementType = collectionElementType as PrimitiveDataType;
if (primitiveElementType != null)
{
IEdmPrimitiveTypeReference primitiveElementTypeReference = GetPrimitiveTypeReference(primitiveElementType);
return(primitiveElementTypeReference.ToCollectionTypeReference());
}
ComplexDataType complexElementType = collectionElementType as ComplexDataType;
if (complexElementType != null)
{
IEdmComplexTypeReference complexElementTypeReference = GetComplexType(model, complexElementType);
return(complexElementTypeReference.ToCollectionTypeReference());
}
EntityDataType entityElementType = collectionElementType as EntityDataType;
if (entityElementType != null)
{
IEdmEntityTypeReference entityElementTypeReference = GetEntityType(model, entityElementType);
return(entityElementTypeReference.ToCollectionTypeReference());
}
throw new NotSupportedException("Collection types only support primitive, complex, and entity element types.");
}
StreamDataType streamType = schemaType as StreamDataType;
if (streamType != null)
{
Type systemType = streamType.GetFacet <PrimitiveClrTypeFacet>().Value;
ExceptionUtilities.Assert(systemType == typeof(Stream), "Expected the system type 'System.IO.Stream' for a stream reference property.");
return(MetadataUtils.GetPrimitiveTypeReference(systemType));
}
throw new NotImplementedException("Unrecognized schema type " + schemaType.GetType().Name + ".");
}
/// <summary>
/// Gets the short qualified Edm name
/// </summary>
/// <param name="dataType">The data type.</param>
/// <returns>short qualified Edm name</returns>
public string Visit(CollectionDataType dataType)
{
throw new TaupoInvalidOperationException(string.Format(CultureInfo.InvariantCulture, "{0} does not have Edm short qualified name.", dataType));
}
/// <summary>
/// Visits the specified collection type.
/// </summary>
/// <param name="dataType">Data type.</param>
/// <returns>the corresponding default query type.</returns>
public QueryType Visit(CollectionDataType dataType)
{
QueryType elementType = this.GetDefaultQueryType(dataType.ElementDataType);
return(elementType.CreateCollectionType());
}
/// <summary>
/// Visits the specified data type.
/// </summary>
/// <param name="dataType">The data type.</param>
/// <returns>Name of the collection type.</returns>
string IDataTypeVisitor <string> .Visit(CollectionDataType dataType)
{
return("Collection(" + this.GetTypeName(dataType.ElementDataType) + ")");
}
/// <summary>
/// Visits the specified data type.
/// </summary>
/// <param name="dataType">The data type to visit.</param>
/// <returns>The data types</returns>
public IEnumerable <DataType> Visit(CollectionDataType dataType)
{
return(this.Gather(dataType.ElementDataType).Concat(dataType));
}
/// <summary>
/// Visits the specified collection type.
/// </summary>
/// <param name="dataType">Data type.</param>
/// <returns>the data type with all references resolved</returns>
public DataType Visit(CollectionDataType dataType)
{
return(DataTypes.CollectionType
.Nullable(dataType.IsNullable)
.WithElementDataType(this.ResolveReferencesIn(dataType.ElementDataType)));
}
