public CsdlSemanticsOperation(CsdlSemanticsSchema context, CsdlOperation operation)
: base(operation)
{
this.Context = context;
this.operation = operation;
}
public CsdlSemanticsLabeledExpression(string name, CsdlExpressionBase element, IEdmEntityType bindingContext, CsdlSemanticsSchema schema)
: base(element)
{
this.name = name;
this.sourceElement = element;
this.bindingContext = bindingContext;
this.schema = schema;
}
public CsdlSemanticsEntityContainer(CsdlSemanticsSchema context, CsdlEntityContainer entityContainer)
: base(entityContainer)
{
this.context = context;
this.entityContainer = entityContainer;
}
public CsdlSemanticsCollectionTypeDefinition(CsdlSemanticsSchema schema, CsdlCollectionType collection)
: base(collection)
{
this.collection = collection;
this.schema = schema;
}
public CsdlSemanticsIsTypeExpression(CsdlIsTypeExpression expression, IEdmEntityType bindingContext, CsdlSemanticsSchema schema)
: base(schema, expression)
{
this.expression = expression;
this.bindingContext = bindingContext;
}
public CsdlSemanticsComplexTypeDefinition(CsdlSemanticsSchema context, CsdlComplexType complex)
: base(context, complex)
{
this.complex = complex;
}
public CsdlSemanticsSpatialTypeReference(CsdlSemanticsSchema schema, CsdlSpatialTypeReference reference)
: base(schema, reference)
{
}
public CsdlSemanticsNamedTypeReference(CsdlSemanticsSchema schema, CsdlNamedTypeReference reference)
: base(reference)
{
this.schema = schema;
this.reference = reference;
}
public CsdlSemanticsBinaryTypeReference(CsdlSemanticsSchema schema, CsdlBinaryTypeReference reference)
: base(schema, reference)
{
}
public CsdlSemanticsTypeDefinitionDefinition(CsdlSemanticsSchema context, CsdlTypeDefinition typeDefinition)
: base(typeDefinition)
{
this.context = context;
this.typeDefinition = typeDefinition;
}
/// <summary>
/// Initializes a new instance of the <see cref="CsdlSemanticsAction"/> class.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="action">The action.</param>
public CsdlSemanticsAction(CsdlSemanticsSchema context, CsdlAction action)
: base(context, action)
{
}
public CsdlSemanticsEntityTypeDefinition(CsdlSemanticsSchema context, CsdlEntityType entity)
: base(context, entity)
{
this.entity = entity;
}
public CsdlSemanticsFunction(CsdlSemanticsSchema context, CsdlFunction function)
: base(context, function)
{
this.function = function;
}
public CsdlSemanticsAnnotationPathExpression(CsdlPathExpression expression, IEdmEntityType bindingContext, CsdlSemanticsSchema schema) : base(expression, bindingContext, schema)
{
}
private void AddSchema(CsdlSchema schema, bool addAnnotations)
{
CsdlSemanticsSchema schemaWrapper = new CsdlSemanticsSchema(this, schema);
this.schemata.Add(schemaWrapper);
foreach (IEdmSchemaType type in schemaWrapper.Types)
{
CsdlSemanticsStructuredTypeDefinition structuredType = type as CsdlSemanticsStructuredTypeDefinition;
if (structuredType != null)
{
string baseTypeNamespace;
string baseTypeName;
string baseTypeFullName = ((CsdlNamedStructuredType)structuredType.Element).BaseTypeName;
if (baseTypeFullName != null)
{
EdmUtil.TryGetNamespaceNameFromQualifiedName(baseTypeFullName, out baseTypeNamespace, out baseTypeName);
if (baseTypeName != null)
{
List <IEdmStructuredType> derivedTypes;
if (!this.derivedTypeMappings.TryGetValue(baseTypeName, out derivedTypes))
{
derivedTypes = new List <IEdmStructuredType>();
this.derivedTypeMappings[baseTypeName] = derivedTypes;
}
// TODO: REF referenced derived types
derivedTypes.Add(structuredType);
}
}
}
RegisterElement(type);
}
foreach (IEdmOperation function in schemaWrapper.Operations)
{
RegisterElement(function);
}
foreach (IEdmTerm valueTerm in schemaWrapper.Terms)
{
RegisterElement(valueTerm);
}
foreach (IEdmEntityContainer container in schemaWrapper.EntityContainers)
{
RegisterElement(container);
}
if (!string.IsNullOrEmpty(schema.Alias))
{
this.SetNamespaceAlias(schema.Namespace, schema.Alias);
}
if (addAnnotations)
{
foreach (CsdlAnnotations schemaOutOfLineAnnotations in schema.OutOfLineAnnotations)
{
string target = schemaOutOfLineAnnotations.Target;
string replaced = this.ReplaceAlias(target);
if (replaced != null)
{
target = replaced;
}
List <CsdlSemanticsAnnotations> annotations;
if (!this.outOfLineAnnotations.TryGetValue(target, out annotations))
{
annotations = new List <CsdlSemanticsAnnotations>();
this.outOfLineAnnotations[target] = annotations;
}
annotations.Add(new CsdlSemanticsAnnotations(schemaWrapper, schemaOutOfLineAnnotations));
}
}
var edmVersion = this.GetEdmVersion();
if (edmVersion == null || edmVersion < schema.Version)
{
this.SetEdmVersion(schema.Version);
}
}
public CsdlSemanticsNavigationPropertyPathExpression(CsdlPathExpression expression, IEdmEntityType bindingContext, CsdlSemanticsSchema schema)
: base(expression, bindingContext, schema)
{
}
protected CsdlSemanticsStructuredTypeDefinition(CsdlSemanticsSchema context, CsdlStructuredType type)
: base(type)
{
this.context = context;
}
public CsdlSemanticsTerm(CsdlSemanticsSchema context, CsdlTerm valueTerm)
: base(valueTerm)
{
this.Context = context;
this.term = valueTerm;
}
public CsdlSemanticsEnumTypeDefinition(CsdlSemanticsSchema context, CsdlEnumType enumeration)
: base(enumeration)
{
this.Context = context;
this.enumeration = enumeration;
}
protected CsdlSemanticsExpression(CsdlSemanticsSchema schema, CsdlExpressionBase element)
: base(element)
{
this.schema = schema;
}
public CsdlSemanticsDateTimeOffsetConstantExpression(CsdlConstantExpression expression, CsdlSemanticsSchema schema)
: base(schema, expression)
{
this.expression = expression;
}
internal static IEdmExpression WrapExpression(CsdlExpressionBase expression, IEdmEntityType bindingContext, CsdlSemanticsSchema schema)
{
if (expression != null)
{
switch (expression.ExpressionKind)
{
case EdmExpressionKind.Cast:
return(new CsdlSemanticsCastExpression((CsdlCastExpression)expression, bindingContext, schema));
case EdmExpressionKind.BinaryConstant:
return(new CsdlSemanticsBinaryConstantExpression((CsdlConstantExpression)expression, schema));
case EdmExpressionKind.BooleanConstant:
return(new CsdlSemanticsBooleanConstantExpression((CsdlConstantExpression)expression, schema));
case EdmExpressionKind.Collection:
return(new CsdlSemanticsCollectionExpression((CsdlCollectionExpression)expression, bindingContext, schema));
case EdmExpressionKind.DateTimeOffsetConstant:
return(new CsdlSemanticsDateTimeOffsetConstantExpression((CsdlConstantExpression)expression, schema));
case EdmExpressionKind.DecimalConstant:
return(new CsdlSemanticsDecimalConstantExpression((CsdlConstantExpression)expression, schema));
case EdmExpressionKind.EnumMember:
return(new CsdlSemanticsEnumMemberExpression((CsdlEnumMemberExpression)expression, bindingContext, schema));
case EdmExpressionKind.FloatingConstant:
return(new CsdlSemanticsFloatingConstantExpression((CsdlConstantExpression)expression, schema));
case EdmExpressionKind.Null:
return(new CsdlSemanticsNullExpression((CsdlConstantExpression)expression, schema));
case EdmExpressionKind.FunctionApplication:
return(new CsdlSemanticsApplyExpression((CsdlApplyExpression)expression, bindingContext, schema));
case EdmExpressionKind.GuidConstant:
return(new CsdlSemanticsGuidConstantExpression((CsdlConstantExpression)expression, schema));
case EdmExpressionKind.If:
return(new CsdlSemanticsIfExpression((CsdlIfExpression)expression, bindingContext, schema));
case EdmExpressionKind.IntegerConstant:
return(new CsdlSemanticsIntConstantExpression((CsdlConstantExpression)expression, schema));
case EdmExpressionKind.IsType:
return(new CsdlSemanticsIsTypeExpression((CsdlIsTypeExpression)expression, bindingContext, schema));
case EdmExpressionKind.LabeledExpressionReference:
return(new CsdlSemanticsLabeledExpressionReferenceExpression((CsdlLabeledExpressionReferenceExpression)expression, bindingContext, schema));
case EdmExpressionKind.Labeled:
return(schema.WrapLabeledElement((CsdlLabeledExpression)expression, bindingContext));
case EdmExpressionKind.Path:
return(new CsdlSemanticsPathExpression((CsdlPathExpression)expression, bindingContext, schema));
case EdmExpressionKind.PropertyPath:
return(new CsdlSemanticsPropertyPathExpression((CsdlPropertyPathExpression)expression, bindingContext, schema));
case EdmExpressionKind.NavigationPropertyPath:
return(new CsdlSemanticsNavigationPropertyPathExpression((CsdlNavigationPropertyPathExpression)expression, bindingContext, schema));
case EdmExpressionKind.Record:
return(new CsdlSemanticsRecordExpression((CsdlRecordExpression)expression, bindingContext, schema));
case EdmExpressionKind.StringConstant:
return(new CsdlSemanticsStringConstantExpression((CsdlConstantExpression)expression, schema));
case EdmExpressionKind.DurationConstant:
return(new CsdlSemanticsDurationConstantExpression((CsdlConstantExpression)expression, schema));
case EdmExpressionKind.DateConstant:
return(new CsdlSemanticsDateConstantExpression((CsdlConstantExpression)expression, schema));
case EdmExpressionKind.TimeOfDayConstant:
return(new CsdlSemanticsTimeOfDayConstantExpression((CsdlConstantExpression)expression, schema));
case EdmExpressionKind.AnnotationPath:
return(new CsdlSemanticsAnnotationPathExpression((CsdlAnnotationPathExpression)expression, bindingContext, schema));
}
}
return(null);
}
public CsdlSemanticsStringTypeReference(CsdlSemanticsSchema schema, CsdlStringTypeReference reference)
: base(schema, reference)
{
}
internal static IEdmTypeReference WrapTypeReference(CsdlSemanticsSchema schema, CsdlTypeReference type)
{
var typeReference = type as CsdlNamedTypeReference;
if (typeReference != null)
{
var primitiveReference = typeReference as CsdlPrimitiveTypeReference;
if (primitiveReference != null)
{
switch (primitiveReference.Kind)
{
case EdmPrimitiveTypeKind.Boolean:
case EdmPrimitiveTypeKind.Byte:
case EdmPrimitiveTypeKind.Date:
case EdmPrimitiveTypeKind.Double:
case EdmPrimitiveTypeKind.Guid:
case EdmPrimitiveTypeKind.Int16:
case EdmPrimitiveTypeKind.Int32:
case EdmPrimitiveTypeKind.Int64:
case EdmPrimitiveTypeKind.SByte:
case EdmPrimitiveTypeKind.Single:
case EdmPrimitiveTypeKind.Stream:
return(new CsdlSemanticsPrimitiveTypeReference(schema, primitiveReference));
case EdmPrimitiveTypeKind.Binary:
return(new CsdlSemanticsBinaryTypeReference(schema, (CsdlBinaryTypeReference)primitiveReference));
case EdmPrimitiveTypeKind.DateTimeOffset:
case EdmPrimitiveTypeKind.Duration:
case EdmPrimitiveTypeKind.TimeOfDay:
return(new CsdlSemanticsTemporalTypeReference(schema, (CsdlTemporalTypeReference)primitiveReference));
case EdmPrimitiveTypeKind.Decimal:
return(new CsdlSemanticsDecimalTypeReference(schema, (CsdlDecimalTypeReference)primitiveReference));
case EdmPrimitiveTypeKind.String:
return(new CsdlSemanticsStringTypeReference(schema, (CsdlStringTypeReference)primitiveReference));
case EdmPrimitiveTypeKind.Geography:
case EdmPrimitiveTypeKind.GeographyPoint:
case EdmPrimitiveTypeKind.GeographyLineString:
case EdmPrimitiveTypeKind.GeographyPolygon:
case EdmPrimitiveTypeKind.GeographyCollection:
case EdmPrimitiveTypeKind.GeographyMultiPolygon:
case EdmPrimitiveTypeKind.GeographyMultiLineString:
case EdmPrimitiveTypeKind.GeographyMultiPoint:
case EdmPrimitiveTypeKind.Geometry:
case EdmPrimitiveTypeKind.GeometryPoint:
case EdmPrimitiveTypeKind.GeometryLineString:
case EdmPrimitiveTypeKind.GeometryPolygon:
case EdmPrimitiveTypeKind.GeometryCollection:
case EdmPrimitiveTypeKind.GeometryMultiPolygon:
case EdmPrimitiveTypeKind.GeometryMultiLineString:
case EdmPrimitiveTypeKind.GeometryMultiPoint:
return(new CsdlSemanticsSpatialTypeReference(schema, (CsdlSpatialTypeReference)primitiveReference));
}
}
else
{
CsdlUntypedTypeReference csdlUntypedTypeReference = typeReference as CsdlUntypedTypeReference;
if (csdlUntypedTypeReference != null)
{
return(new CsdlSemanticsUntypedTypeReference(schema, csdlUntypedTypeReference));
}
if (schema.FindType(typeReference.FullName) is IEdmTypeDefinition)
{
return(new CsdlSemanticsTypeDefinitionReference(schema, typeReference));
}
}
return(new CsdlSemanticsNamedTypeReference(schema, typeReference));
}
var typeExpression = type as CsdlExpressionTypeReference;
if (typeExpression != null)
{
var collectionType = typeExpression.TypeExpression as CsdlCollectionType;
if (collectionType != null)
{
return(new CsdlSemanticsCollectionTypeExpression(typeExpression, new CsdlSemanticsCollectionTypeDefinition(schema, collectionType)));
}
var entityReferenceType = typeExpression.TypeExpression as CsdlEntityReferenceType;
if (entityReferenceType != null)
{
return(new CsdlSemanticsEntityReferenceTypeExpression(typeExpression, new CsdlSemanticsEntityReferenceTypeDefinition(schema, entityReferenceType)));
}
}
return(null);
}
public CsdlSemanticsTemporalTypeReference(CsdlSemanticsSchema schema, CsdlTemporalTypeReference reference)
: base(schema, reference)
{
}
internal IEnumerable <IEdmVocabularyAnnotation> WrapInlineVocabularyAnnotations(CsdlSemanticsElement element, CsdlSemanticsSchema schema)
{
IEdmVocabularyAnnotatable vocabularyAnnotatableElement = element as IEdmVocabularyAnnotatable;
if (vocabularyAnnotatableElement != null)
{
IEnumerable <CsdlAnnotation> vocabularyAnnotations = element.Element.VocabularyAnnotations;
if (vocabularyAnnotations.FirstOrDefault() != null)
{
List <IEdmVocabularyAnnotation> wrappedAnnotations = new List <IEdmVocabularyAnnotation>();
foreach (CsdlAnnotation vocabularyAnnotation in vocabularyAnnotations)
{
IEdmVocabularyAnnotation vocabAnnotation = this.WrapVocabularyAnnotation(vocabularyAnnotation, schema, vocabularyAnnotatableElement, null, vocabularyAnnotation.Qualifier);
vocabAnnotation.SetSerializationLocation(this, EdmVocabularyAnnotationSerializationLocation.Inline);
wrappedAnnotations.Add(vocabAnnotation);
}
return(wrappedAnnotations);
}
}
return(Enumerable.Empty <IEdmVocabularyAnnotation>());
}
public CsdlSemanticsFunctionImport(CsdlSemanticsEntityContainer container, CsdlFunctionImport functionImport, IEdmFunction backingfunction)
: base(container, functionImport, backingfunction)
{
this.csdlSchema = container.Context;
this.functionImport = functionImport;
}
private IEdmVocabularyAnnotation WrapVocabularyAnnotation(CsdlAnnotation annotation, CsdlSemanticsSchema schema, IEdmVocabularyAnnotatable targetContext, CsdlSemanticsAnnotations annotationsContext, string qualifier)
{
return(EdmUtil.DictionaryGetOrUpdate(
this.wrappedAnnotations,
annotation,
ann => new CsdlSemanticsVocabularyAnnotation(schema, targetContext, annotationsContext, ann, qualifier)));
}
public CsdlSemanticsBinaryConstantExpression(CsdlConstantExpression expression, CsdlSemanticsSchema schema)
: base(schema, expression)
{
this.expression = expression;
}
public CsdlSemanticsDecimalTypeReference(CsdlSemanticsSchema schema, CsdlDecimalTypeReference reference)
: base(schema, reference)
{
}
