/// <summary>
/// Creates a new parameter for the specified function import.
/// </summary>
/// <param name="functionImport">The <see cref="FunctionImport"/> to add the parameter to.</param>
/// <param name="name">The local name of the parameter.</param>
/// <param name="returnType">The type of the function parameter.</param>
/// <param name="mode">The paramter mode.</param>
/// <returns>The <paramref name="functionImport"/> (for composability).</returns>
public static FunctionImport ReturnType(this FunctionImport functionImport, DataType returnDataType, EntitySet entitySet = null)
{
ExceptionUtilities.CheckArgumentNotNull(functionImport, "functionImport");
ExceptionUtilities.CheckArgumentNotNull(returnDataType, "returnDataType");
FunctionImportReturnType returnType = new FunctionImportReturnType(returnDataType, entitySet);
functionImport.ReturnTypes.Add(returnType);
return(functionImport);
}
private FunctionImport ConvertToTaupoFunctionImport(IEdmOperationImport edmFunctionImport)
{
var taupoFunctionImport = new FunctionImport(edmFunctionImport.Name);
var functionImportReturnType = new FunctionImportReturnType();
var addReturnType = false;
if (edmFunctionImport.EntitySet != null)
{
IEdmEntitySet entitySet;
if (edmFunctionImport.TryGetStaticEntitySet(out entitySet))
{
functionImportReturnType.EntitySet = new EntitySetReference(entitySet.Name);
addReturnType = true;
}
else
{
throw new NotSupportedException("Function import with entity set path is not supported.");
}
}
if (edmFunctionImport.Operation.ReturnType != null)
{
functionImportReturnType.DataType = this.ConvertToTaupoDataType(edmFunctionImport.Operation.ReturnType);
addReturnType = true;
}
if (addReturnType)
{
taupoFunctionImport.Add(functionImportReturnType);
}
foreach (var edmFunctionParameter in edmFunctionImport.Operation.Parameters)
{
FunctionParameter taupoFunctionParameter = this.ConvertToTaupoFunctionParameter(edmFunctionParameter);
taupoFunctionImport.Parameters.Add(taupoFunctionParameter);
}
this.ConvertAnnotationsIntoTaupo(edmFunctionImport, taupoFunctionImport);
return(taupoFunctionImport);
}
/// <summary>
/// Compares the actual function import against the expected.
/// </summary>
/// <param name="expectedFunctionImport">expected function import</param>
/// <param name="actualFunctionImport">actual import</param>
protected virtual void CompareFunctionImport(FunctionImport expectedFunctionImport, FunctionImport actualFunctionImport)
{
this.WriteErrorIfFalse(expectedFunctionImport.Name == actualFunctionImport.Name, "Wrong FunctionImport to compare.");
// verify return type
this.WriteErrorIfFalse(expectedFunctionImport.ReturnTypes.Count == actualFunctionImport.ReturnTypes.Count, "Wrong number of return type.");
FunctionImportReturnType expectedReturnType = null;
FunctionImportReturnType actualReturnType = null;
if (expectedFunctionImport.ReturnTypes.Any())
{
expectedReturnType = expectedFunctionImport.ReturnTypes.Single();
actualReturnType = actualFunctionImport.ReturnTypes.Single();
this.WriteErrorIfFalse(expectedReturnType.DataType.GetType().Equals(actualReturnType.DataType.GetType()), "Expected Return Type {0} is not equal to actual Return Type {1}", expectedReturnType.DataType.GetType(), actualReturnType.DataType.GetType());
if (expectedReturnType.EntitySet == null)
{
this.WriteErrorIfFalse(actualReturnType.EntitySet == null, "Expected EntitySet {0} is not equal to actual EntitySet {1} {2}", expectedReturnType.EntitySet, actualReturnType.EntitySet, actualFunctionImport.Name);
}
else
{
this.WriteErrorIfFalse(expectedReturnType.EntitySet.Name == actualReturnType.EntitySet.Name, "Expected EntitySet {0} is not equal to actual EntitySet {1} {2}", expectedReturnType.EntitySet, actualReturnType.EntitySet, actualFunctionImport.Name);
}
}
// verify parameters
ExceptionUtilities.Assert(expectedFunctionImport.Parameters.Count == actualFunctionImport.Parameters.Count, "Wrong number of parameters.");
foreach (FunctionParameter expectedParameter in expectedFunctionImport.Parameters)
{
FunctionParameter actualParameter = actualFunctionImport.Parameters.Single(p => p.Name == expectedParameter.Name);
this.WriteErrorIfFalse(expectedParameter.DataType.GetType().Equals(actualParameter.DataType.GetType()), "Wrong parameter type, Expected {0}, Actual {1}", expectedParameter.DataType.GetType(), actualParameter.DataType.GetType());
this.WriteErrorIfFalse(expectedParameter.Mode == actualParameter.Mode, "Wrong parameter mode, Expected {0}, Actual {1}.", expectedParameter.Mode, actualParameter.Mode);
}
this.WriteErrorIfFalse(expectedFunctionImport.IsBindable == actualFunctionImport.IsBindable, "FunctionImport.IsBindable is not equal, Expected {0}, Actual: {1}", expectedFunctionImport.IsBindable, actualFunctionImport.IsBindable);
this.WriteErrorIfFalse(expectedFunctionImport.IsComposable == actualFunctionImport.IsComposable, "FunctionImport.IsComposable is not equal, Expected {0}, Actual: {1}", expectedFunctionImport.IsComposable, actualFunctionImport.IsComposable);
this.WriteErrorIfFalse(expectedFunctionImport.IsSideEffecting == actualFunctionImport.IsSideEffecting, "FunctionImport.IsSideEffecting is not equal, Expected {0}, Actual: {1}", expectedFunctionImport.IsSideEffecting, actualFunctionImport.IsSideEffecting);
}
private FunctionImport ParseFunctionImport(XElement functionImportElement)
{
string functionImportName = functionImportElement.GetRequiredAttributeValue("Name");
var functionImport = new FunctionImport(functionImportName);
bool isComposable = XmlConvert.ToBoolean(functionImportElement.GetOptionalAttributeValue("IsComposable", "false"));
functionImport.IsComposable = isComposable;
bool isBindable = XmlConvert.ToBoolean(functionImportElement.GetOptionalAttributeValue("IsBindable", "false"));
functionImport.IsBindable = isBindable;
bool isSideEffecting = XmlConvert.ToBoolean(functionImportElement.GetOptionalAttributeValue("IsSideEffecting", "true"));
functionImport.IsSideEffecting = isSideEffecting;
string entitySetPath = functionImportElement.GetOptionalAttributeValue("EntitySetPath", null);
if (entitySetPath != null)
{
functionImport.Annotations.Add(new EntitySetPathAnnotation(entitySetPath));
}
foreach (var parameterElement in functionImportElement.Elements().Where(el => this.IsXsdlElement(el, "Parameter")))
{
functionImport.Parameters.Add(this.ParseFunctionParameter(parameterElement));
}
string returnTypeName = functionImportElement.GetOptionalAttributeValue("ReturnType", null);
if (returnTypeName != null)
{
bool isNullable = XmlConvert.ToBoolean(functionImportElement.GetOptionalAttributeValue("Nullable", "true"));
var returnType = new FunctionImportReturnType(this.ParseType(returnTypeName, isNullable, null));
string entitySetName = functionImportElement.GetOptionalAttributeValue("EntitySet", null);
if (entitySetName != null)
{
returnType.EntitySet = new EntitySetReference(entitySetName);
}
functionImport.Add(returnType);
}
foreach (var returnTypeElement in functionImportElement.Elements().Where(el => this.IsXsdlElement(el, "ReturnType")))
{
var type = returnTypeElement.GetRequiredAttributeValue("Type");
var returnType = new FunctionImportReturnType(this.ParseType(type, true, null));
var entitySet = returnTypeElement.GetOptionalAttributeValue("EntitySet", null);
if (entitySet != null)
{
returnType.EntitySet = new EntitySetReference(entitySet);
}
functionImport.ReturnTypes.Add(returnType);
}
string methodaccess = functionImportElement.GetOptionalAttributeValue(EdmConstants.CodegenNamespace + "MethodAccess", null);
if (methodaccess != null)
{
functionImport.Annotations.Add(new MethodAccessModifierAnnotation(this.GetAccessModifier(methodaccess)));
}
this.ParseAnnotations(functionImport, functionImportElement);
return(functionImport);
}
