// <summary>
// Validates whether facets are declared correctly.
// </summary>
// <param name="element"> Schema element being validated. Must not be null. </param>
// <param name="type"> Resolved type (from declaration on the element). Possibly null. </param>
// <param name="typeUsageBuilder"> TypeUsageBuilder for the current element. Must not be null. </param>
internal static void ValidateFacets(SchemaElement element, SchemaType type, TypeUsageBuilder typeUsageBuilder)
{
DebugCheck.NotNull(element);
DebugCheck.NotNull(typeUsageBuilder);
if (type != null)
{
var schemaEnumType = type as SchemaEnumType;
if (schemaEnumType != null)
{
typeUsageBuilder.ValidateEnumFacets(schemaEnumType);
}
else if (!(type is ScalarType)
&& typeUsageBuilder.HasUserDefinedFacets)
{
Debug.Assert(!(type is SchemaEnumType), "Note that enums should have already been handled.");
// Non-scalar type should not have Facets.
element.AddError(
ErrorCode.FacetOnNonScalarType, EdmSchemaErrorSeverity.Error, Strings.FacetsOnNonScalarType(type.FQName));
}
}
else
{
if (typeUsageBuilder.HasUserDefinedFacets)
{
// Type attribute not specified but facets exist.
element.AddError(
ErrorCode.IncorrectlyPlacedFacet, EdmSchemaErrorSeverity.Error, Strings.FacetDeclarationRequiresTypeAttribute);
}
}
}
// <summary>
// Validated whether a type is declared correctly.
// </summary>
// <param name="element"> Schema element being validated. Must not be null. </param>
// <param name="type"> Resolved type (from declaration on the element). Possibly null. </param>
// <param name="typeSubElement"> Child schema element. Possibly null. </param>
// <remarks>
// For some elements (e.g. ReturnType) we allow the type to be defined inline in an attribute on the element itself or
// by using nested elements. These definitions are mutually exclusive.
// </remarks>
internal static void ValidateTypeDeclaration(SchemaElement element, SchemaType type, SchemaElement typeSubElement)
{
DebugCheck.NotNull(element);
if (type == null
&& typeSubElement == null)
{
//Type not declared as either attribute or subelement
element.AddError(ErrorCode.TypeNotDeclared, EdmSchemaErrorSeverity.Error, Strings.TypeMustBeDeclared);
}
if (type != null
&& typeSubElement != null)
{
//Both attribute and sub-element declarations exist
element.AddError(
ErrorCode.TypeDeclaredAsAttributeAndElement, EdmSchemaErrorSeverity.Error, Strings.TypeDeclaredAsAttributeAndElement);
}
}
internal CollectionTypeElement(SchemaElement parentElement)
: base(parentElement)
{
}
internal virtual SchemaElement Clone(SchemaElement parentElement)
{
throw Error.NotImplemented();
}
/// <summary>
/// </summary>
/// <param name="parentElement"> </param>
internal SchemaElement(SchemaElement parentElement)
{
if (parentElement != null)
{
ParentElement = parentElement;
for (var element = parentElement; element != null; element = element.ParentElement)
{
var schema = element as Schema;
if (schema != null)
{
Schema = schema;
break;
}
}
if (Schema == null)
{
throw new InvalidOperationException(Strings.AllElementsMustBeInSchema);
}
}
}
internal SchemaElement(SchemaElement parentElement, string name)
: this(parentElement)
{
_name = name;
}
internal override SchemaElement Clone(SchemaElement parentElement)
{
var parameter = new Parameter((Function)parentElement);
parameter._collectionKind = _collectionKind;
parameter._parameterDirection = _parameterDirection;
parameter._type = _type;
parameter.Name = Name;
parameter._typeUsageBuilder = _typeUsageBuilder;
return parameter;
}
// <summary>
// Look up a fully qualified type name reference.
// </summary>
// <param name="usingElement"> element containing the reference </param>
// <param name="typeName"> the fully qualified type name </param>
// <param name="type"> the referenced schema type </param>
// <returns> false if there was an error </returns>
internal bool ResolveTypeName(SchemaElement usingElement, string typeName, out SchemaType type)
{
DebugCheck.NotNull(usingElement);
DebugCheck.NotNull(typeName);
type = null;
// get the schema(s) that match the namespace/alias
string actualQualification;
string unqualifiedTypeName;
Utils.ExtractNamespaceAndName(typeName, out actualQualification, out unqualifiedTypeName);
var definingQualification = actualQualification;
if (definingQualification == null)
{
definingQualification = ProviderManifest == null ? _namespaceName : ProviderManifest.NamespaceName;
}
string namespaceName;
// First check if there is an alias defined by this name. For primitive type namespace, we do not need to resolve
// any alias, since that's a reserved keyword and we don't allow alias with that name
if (actualQualification == null
|| !AliasResolver.TryResolveAlias(definingQualification, out namespaceName))
{
namespaceName = definingQualification;
}
// Resolve the type name
if (!SchemaManager.TryResolveType(namespaceName, unqualifiedTypeName, out type))
{
// it must be an undefined type.
if (actualQualification == null)
{
// Every type except the primitive type must be qualified
usingElement.AddError(ErrorCode.NotInNamespace, EdmSchemaErrorSeverity.Error, Strings.NotNamespaceQualified(typeName));
}
else if (!SchemaManager.IsValidNamespaceName(namespaceName))
{
usingElement.AddError(
ErrorCode.BadNamespace, EdmSchemaErrorSeverity.Error, Strings.BadNamespaceOrAlias(actualQualification));
}
else
{
// if the type name was alias qualified
if (namespaceName != definingQualification)
{
usingElement.AddError(
ErrorCode.NotInNamespace, EdmSchemaErrorSeverity.Error,
Strings.NotInNamespaceAlias(unqualifiedTypeName, namespaceName, definingQualification));
}
else
{
usingElement.AddError(
ErrorCode.NotInNamespace, EdmSchemaErrorSeverity.Error,
Strings.NotInNamespaceNoAlias(unqualifiedTypeName, namespaceName));
}
}
return false;
}
// For ssdl and provider manifest, make sure that the type is present in this schema or primitive schema
else if (DataModel != SchemaDataModelOption.EntityDataModel
&& type.Schema != this
&& type.Schema != SchemaManager.PrimitiveSchema)
{
Debug.Assert(type.Namespace != Namespace, "Using element is not allowed in the schema of ssdl and provider manifest");
usingElement.AddError(
ErrorCode.InvalidNamespaceOrAliasSpecified, EdmSchemaErrorSeverity.Error,
Strings.InvalidNamespaceOrAliasSpecified(actualQualification));
return false;
}
return true;
}
private void DuplicateOrEquivalentMemberNameWhileExtendingEntityContainer(
SchemaElement schemaElement,
AddErrorKind error)
{
Debug.Assert(
error != AddErrorKind.MissingNameError, "Since entity container members are already resolved, name must never be empty");
Debug.Assert(ExtendingEntityContainer != null, "ExtendingEntityContainer must not be null");
if (error != AddErrorKind.Succeeded)
{
Debug.Assert(error == AddErrorKind.DuplicateNameError, "Error must be duplicate name error");
schemaElement.AddError(
ErrorCode.AlreadyDefined, EdmSchemaErrorSeverity.Error,
Strings.DuplicateMemberNameInExtendedEntityContainer(
schemaElement.Name, ExtendingEntityContainer.Name, Name));
}
}
// <summary>
// Initializes a new instance of the <see cref="SchemaEnumMember" /> class.
// </summary>
// <param name="parentElement"> Parent element. </param>
public SchemaEnumMember(SchemaElement parentElement)
: base(parentElement)
{
}
internal TypeRefElement(SchemaElement parentElement)
: base(parentElement)
{
}
internal override SchemaElement Clone(SchemaElement parentElement)
{
throw Error.NotImplemented();
}
/// <summary>
/// validate the following negative scenarios:
/// ReturnType="Collection(EntityTypeA)"
/// ReturnType="Collection(EntityTypeA)" EntitySet="ESet.EType is not oftype EntityTypeA"
/// EntitySet="A"
/// ReturnType="Collection(ComplexTypeA)" EntitySet="something"
/// ReturnType="Collection(ComplexTypeA)", but the ComplexTypeA has a nested complexType property, this scenario will be handle in the runtime
/// </summary>
private void ValidateFunctionImportReturnType(
SchemaElement owner, SchemaType returnType, EntityContainerEntitySet entitySet, bool entitySetPathDefined)
{
// If entity type, verify specification of entity set and that the type is appropriate for the entity set
var entityType = returnType as SchemaEntityType;
if (entitySet != null && entitySetPathDefined)
{
owner.AddError(
ErrorCode.FunctionImportEntitySetAndEntitySetPathDeclared,
EdmSchemaErrorSeverity.Error,
Strings.FunctionImportEntitySetAndEntitySetPathDeclared(FQName));
}
if (null != entityType)
{
// entity type
if (null == entitySet)
{
// ReturnType="Collection(EntityTypeA)"
owner.AddError(
ErrorCode.FunctionImportReturnsEntitiesButDoesNotSpecifyEntitySet,
EdmSchemaErrorSeverity.Error,
Strings.FunctionImportReturnEntitiesButDoesNotSpecifyEntitySet(FQName));
}
else if (null != entitySet.EntityType &&
!entityType.IsOfType(entitySet.EntityType))
{
// ReturnType="Collection(EntityTypeA)" EntitySet="ESet.EType is not oftype EntityTypeA"
owner.AddError(
ErrorCode.FunctionImportEntityTypeDoesNotMatchEntitySet,
EdmSchemaErrorSeverity.Error,
Strings.FunctionImportEntityTypeDoesNotMatchEntitySet(
FQName, entitySet.EntityType.FQName, entitySet.Name));
}
}
else
{
// complex type
var complexType = returnType as SchemaComplexType;
if (complexType != null)
{
if (entitySet != null || entitySetPathDefined)
{
// ReturnType="Collection(ComplexTypeA)" EntitySet="something"
owner.AddError(
ErrorCode.ComplexTypeAsReturnTypeAndDefinedEntitySet,
EdmSchemaErrorSeverity.Error,
owner.LineNumber,
owner.LinePosition,
Strings.ComplexTypeAsReturnTypeAndDefinedEntitySet(FQName, complexType.Name));
}
}
else
{
Debug.Assert(
returnType == null || returnType is ScalarType || returnType is SchemaEnumType || returnType is Relationship,
"null return type, scalar return type, enum return type or relationship expected here.");
// scalar type or no return type
if (entitySet != null || entitySetPathDefined)
{
// EntitySet="A"
owner.AddError(
ErrorCode.FunctionImportSpecifiesEntitySetButDoesNotReturnEntityType,
EdmSchemaErrorSeverity.Error,
Strings.FunctionImportSpecifiesEntitySetButNotEntityType(FQName));
}
}
}
}
internal RowTypePropertyElement(SchemaElement parentElement)
: base(parentElement)
{
_typeUsageBuilder = new TypeUsageBuilder(this);
}
internal virtual SchemaElement Clone(SchemaElement parentElement)
{
throw Error.NotImplemented();
}
internal ModelFunctionTypeElement(SchemaElement parentElement)
: base(parentElement)
{
_typeUsageBuilder = new TypeUsageBuilder(this);
}
internal CollectionTypeElement(SchemaElement parentElement)
: base(parentElement)
{
}
internal override SchemaElement Clone(SchemaElement parentElement)
{
var entitySet = new EntityContainerEntitySet((EntityContainer)parentElement);
entitySet._definingQueryElement = _definingQueryElement;
entitySet._entityType = _entityType;
entitySet._schema = _schema;
entitySet._table = _table;
entitySet.Name = Name;
return entitySet;
}
public DocumentationElement(SchemaElement parentElement)
: base(parentElement, (IDbDependencyResolver)null)
{
}
/// <summary>
/// See if a name is a member in a type or any of its base types
/// </summary>
/// <param name="name"> name to look for </param>
/// <param name="definingType"> if defined, the type that defines it </param>
/// <param name="definingMember"> if defined, the member that defines it </param>
/// <returns> how name was defined </returns>
private HowDefined DefinesMemberName(string name, out StructuredType definingType, out SchemaElement definingMember)
{
if (NamedMembers.ContainsKey(name))
{
definingType = this;
definingMember = NamedMembers[name];
return HowDefined.AsMember;
}
definingMember = NamedMembers.LookUpEquivalentKey(name);
Debug.Assert(definingMember == null, "we allow the scenario that members can have same name but different cases");
if (IsTypeHierarchyRoot)
{
definingType = null;
definingMember = null;
return HowDefined.NotDefined;
}
return BaseType.DefinesMemberName(name, out definingType, out definingMember);
}
internal FacetEnabledSchemaElement(SchemaElement parentElement)
: base(parentElement)
{
}
/// <summary>
/// </summary>
/// <param name="parentElement"> </param>
internal ReferenceTypeElement(SchemaElement parentElement)
: base(parentElement)
{
}
// <summary>
// See if a name is a member in a type or any of its base types
// </summary>
// <param name="name"> name to look for </param>
// <param name="definingType"> if defined, the type that defines it </param>
// <param name="definingMember"> if defined, the member that defines it </param>
// <returns> how name was defined </returns>
private HowDefined DefinesMemberName(string name, out StructuredType definingType, out SchemaElement definingMember)
{
if (NamedMembers.ContainsKey(name))
{
definingType = this;
definingMember = NamedMembers[name];
return(HowDefined.AsMember);
}
definingMember = NamedMembers.LookUpEquivalentKey(name);
Debug.Assert(definingMember == null, "we allow the scenario that members can have same name but different cases");
if (IsTypeHierarchyRoot)
{
definingType = null;
definingMember = null;
return(HowDefined.NotDefined);
}
return(BaseType.DefinesMemberName(name, out definingType, out definingMember));
}
/// <summary>
/// </summary>
/// <param name="errorCode"> </param>
/// <param name="severity"> </param>
/// <param name="element"> </param>
/// <param name="message"> </param>
internal void AddError(ErrorCode errorCode, EdmSchemaErrorSeverity severity, SchemaElement element, object message)
{
AddError(errorCode, severity, element.Schema.Location, element.LineNumber, element.LinePosition, message);
}
// <summary>
// Validated whether a type is declared correctly.
// </summary>
// <param name="element"> Schema element being validated. Must not be null. </param>
// <param name="type"> Resolved type (from declaration on the element). Possibly null. </param>
// <param name="typeSubElement"> Child schema element. Possibly null. </param>
// <remarks>
// For some elements (e.g. ReturnType) we allow the type to be defined inline in an attribute on the element itself or
// by using nested elements. These definitions are mutually exclusive.
// </remarks>
internal static void ValidateTypeDeclaration(SchemaElement element, SchemaType type, SchemaElement typeSubElement)
{
DebugCheck.NotNull(element);
if (type == null &&
typeSubElement == null)
{
//Type not declared as either attribute or subelement
element.AddError(ErrorCode.TypeNotDeclared, EdmSchemaErrorSeverity.Error, Strings.TypeMustBeDeclared);
}
if (type != null &&
typeSubElement != null)
{
//Both attribute and sub-element declarations exist
element.AddError(
ErrorCode.TypeDeclaredAsAttributeAndElement, EdmSchemaErrorSeverity.Error, Strings.TypeDeclaredAsAttributeAndElement);
}
}
internal SchemaElement(SchemaElement parentElement, string name)
: this(parentElement)
{
_name = name;
}
public TextElement(SchemaElement parentElement)
: base(parentElement)
{
}
internal TypeUsageBuilder(SchemaElement element)
{
_element = element;
_facetValues = new Dictionary<string, object>();
}
private bool InternalHandleAttribute(XmlReader reader)
{
if (SchemaElement.CanHandleAttribute(reader, DbProviderManifest.NullableFacetName))
{
HandleNullableAttribute(reader);
return(true);
}
else if (SchemaElement.CanHandleAttribute(reader, XmlConstants.DefaultValueAttribute))
{
HandleDefaultAttribute(reader);
return(true);
}
else if (SchemaElement.CanHandleAttribute(reader, DbProviderManifest.PrecisionFacetName))
{
HandlePrecisionAttribute(reader);
return(true);
}
else if (SchemaElement.CanHandleAttribute(reader, DbProviderManifest.ScaleFacetName))
{
HandleScaleAttribute(reader);
return(true);
}
else if (SchemaElement.CanHandleAttribute(reader, EdmProviderManifest.StoreGeneratedPatternFacetName))
{
HandleStoreGeneratedPatternAttribute(reader);
return(true);
}
else if (SchemaElement.CanHandleAttribute(reader, EdmProviderManifest.ConcurrencyModeFacetName))
{
HandleConcurrencyModeAttribute(reader);
return(true);
}
else if (SchemaElement.CanHandleAttribute(reader, DbProviderManifest.MaxLengthFacetName))
{
HandleMaxLengthAttribute(reader);
return(true);
}
else if (SchemaElement.CanHandleAttribute(reader, DbProviderManifest.UnicodeFacetName))
{
HandleUnicodeAttribute(reader);
return(true);
}
else if (SchemaElement.CanHandleAttribute(reader, DbProviderManifest.CollationFacetName))
{
HandleCollationAttribute(reader);
return(true);
}
else if (SchemaElement.CanHandleAttribute(reader, DbProviderManifest.FixedLengthFacetName))
{
HandleIsFixedLengthAttribute(reader);
return(true);
}
else if (SchemaElement.CanHandleAttribute(reader, DbProviderManifest.NullableFacetName))
{
HandleNullableAttribute(reader);
return(true);
}
else if (SchemaElement.CanHandleAttribute(reader, DbProviderManifest.SridFacetName))
{
HandleSridAttribute(reader);
return(true);
}
return(false);
}
internal TypeUsageBuilder(SchemaElement element)
{
_element = element;
_facetValues = new Dictionary <string, object>();
}
internal RowTypeElement(SchemaElement parentElement)
: base(parentElement)
{
}
// <summary>
// Validate that reference type is an entity type.
// </summary>
// <param name="element"> Schema element being validated. Must not be null. </param>
// <param name="type"> Resolved type (from declaration on the element). Possibly null. </param>
internal static void ValidateRefType(SchemaElement element, SchemaType type)
{
DebugCheck.NotNull(element);
if (type != null
&& !(type is SchemaEntityType))
{
// Ref type refers to non entity type.
element.AddError(
ErrorCode.ReferenceToNonEntityType, EdmSchemaErrorSeverity.Error, Strings.ReferenceToNonEntityType(type.FQName));
}
}
private static void AddOtherContent(SchemaElement element, MetadataItem item)
{
if (element.OtherContent.Count > 0)
{
item.AddMetadataProperties(element.OtherContent);
}
}
internal RowTypeElement(SchemaElement parentElement)
: base(parentElement)
{
}
/// <summary>
/// construct a KeyProperty object
/// </summary>
/// <param name="parentElement"> </param>
public PropertyRefElement(SchemaElement parentElement)
: base(parentElement)
{
}
internal override SchemaElement Clone(SchemaElement parentElement)
{
var setEnd = new EntityContainerAssociationSetEnd((EntityContainerAssociationSet)parentElement);
setEnd._unresolvedRelationshipEndRole = _unresolvedRelationshipEndRole;
setEnd.EntitySet = EntitySet;
return setEnd;
}
internal void ResolveEntitySet(SchemaElement owner, string unresolvedEntitySet, ref EntityContainerEntitySet entitySet)
{
Debug.Assert(IsFunctionImport, "Only FunctionImport elkements specify EntitySets");
Debug.Assert(null != _container, "function imports must know container");
// resolve entity set
if (null == entitySet
&& null != unresolvedEntitySet)
{
entitySet = _container.FindEntitySet(unresolvedEntitySet);
if (null == entitySet)
{
owner.AddError(
ErrorCode.FunctionImportUnknownEntitySet,
EdmSchemaErrorSeverity.Error,
Strings.FunctionImportUnknownEntitySet(unresolvedEntitySet, FQName));
}
}
}
internal override SchemaElement Clone(SchemaElement parentElement)
{
// We only support clone for FunctionImports.
throw Error.NotImplemented();
}
private void ValidateFunctionImportReturnType(
SchemaElement owner, SchemaType returnType, CollectionKind returnTypeCollectionKind, EntityContainerEntitySet entitySet,
bool entitySetPathDefined)
{
if (returnType != null
&& !ReturnTypeMeetsFunctionImportBasicRequirements(returnType, returnTypeCollectionKind))
{
owner.AddError(
ErrorCode.FunctionImportUnsupportedReturnType,
EdmSchemaErrorSeverity.Error,
owner,
GetReturnTypeErrorMessage(Name)
);
}
ValidateFunctionImportReturnType(owner, returnType, entitySet, entitySetPathDefined);
}
/// <summary>
/// Add a member to the type
/// </summary>
/// <param name="newMember"> the member being added </param>
protected void AddMember(SchemaElement newMember)
{
DebugCheck.NotNull(newMember);
if (string.IsNullOrEmpty(newMember.Name))
{
// this is an error condition that has already been reported.
return;
}
if (Schema.DataModel != SchemaDataModelOption.ProviderDataModel
&& Utils.CompareNames(newMember.Name, Name) == 0)
{
newMember.AddError(
ErrorCode.BadProperty, EdmSchemaErrorSeverity.Error,
Strings.InvalidMemberNameMatchesTypeName(newMember.Name, FQName));
}
NamedMembers.Add(newMember, true, Strings.PropertyNameAlreadyDefinedDuplicate);
}
/// <summary>
/// validate the following negative scenarios:
/// ReturnType="Collection(EntityTypeA)"
/// ReturnType="Collection(EntityTypeA)" EntitySet="ESet.EType is not oftype EntityTypeA"
/// EntitySet="A"
/// ReturnType="Collection(ComplexTypeA)" EntitySet="something"
/// ReturnType="Collection(ComplexTypeA)", but the ComplexTypeA has a nested complexType property, this scenario will be handle in the runtime
/// </summary>
private void ValidateFunctionImportReturnType(
SchemaElement owner, SchemaType returnType, EntityContainerEntitySet entitySet, bool entitySetPathDefined)
{
// If entity type, verify specification of entity set and that the type is appropriate for the entity set
var entityType = returnType as SchemaEntityType;
if (entitySet != null && entitySetPathDefined)
{
owner.AddError(
ErrorCode.FunctionImportEntitySetAndEntitySetPathDeclared,
EdmSchemaErrorSeverity.Error,
Strings.FunctionImportEntitySetAndEntitySetPathDeclared(FQName));
}
if (null != entityType)
{
// entity type
if (null == entitySet)
{
// ReturnType="Collection(EntityTypeA)"
owner.AddError(
ErrorCode.FunctionImportReturnsEntitiesButDoesNotSpecifyEntitySet,
EdmSchemaErrorSeverity.Error,
Strings.FunctionImportReturnEntitiesButDoesNotSpecifyEntitySet(FQName));
}
else if (null != entitySet.EntityType
&& !entityType.IsOfType(entitySet.EntityType))
{
// ReturnType="Collection(EntityTypeA)" EntitySet="ESet.EType is not oftype EntityTypeA"
owner.AddError(
ErrorCode.FunctionImportEntityTypeDoesNotMatchEntitySet,
EdmSchemaErrorSeverity.Error,
Strings.FunctionImportEntityTypeDoesNotMatchEntitySet(
FQName, entitySet.EntityType.FQName, entitySet.Name));
}
}
else
{
// complex type
var complexType = returnType as SchemaComplexType;
if (complexType != null)
{
if (entitySet != null || entitySetPathDefined)
{
// ReturnType="Collection(ComplexTypeA)" EntitySet="something"
owner.AddError(
ErrorCode.ComplexTypeAsReturnTypeAndDefinedEntitySet,
EdmSchemaErrorSeverity.Error,
owner.LineNumber,
owner.LinePosition,
Strings.ComplexTypeAsReturnTypeAndDefinedEntitySet(FQName, complexType.Name));
}
}
else
{
Debug.Assert(
returnType == null || returnType is ScalarType || returnType is SchemaEnumType || returnType is Relationship,
"null return type, scalar return type, enum return type or relationship expected here.");
// scalar type or no return type
if (entitySet != null || entitySetPathDefined)
{
// EntitySet="A"
owner.AddError(
ErrorCode.FunctionImportSpecifiesEntitySetButDoesNotReturnEntityType,
EdmSchemaErrorSeverity.Error,
Strings.FunctionImportSpecifiesEntitySetButNotEntityType(FQName));
}
}
}
}
internal FacetEnabledSchemaElement(SchemaElement parentElement)
: base(parentElement)
{
}
internal override SchemaElement Clone(SchemaElement parentElement)
{
var function = new FunctionImportElement((EntityContainer)parentElement);
CloneSetFunctionFields(function);
function._container = _container;
function._entitySet = _entitySet;
function._unresolvedEntitySet = _unresolvedEntitySet;
function._entitySetPathDefined = _entitySetPathDefined;
return function;
}
internal RowTypePropertyElement(SchemaElement parentElement)
: base(parentElement)
{
_typeUsageBuilder = new TypeUsageBuilder(this);
}
internal override SchemaElement Clone(SchemaElement parentElement)
{
var parameter = new ReturnType((Function)parentElement);
parameter._type = _type;
parameter.Name = Name;
parameter._typeUsageBuilder = _typeUsageBuilder;
parameter._unresolvedType = _unresolvedType;
parameter._unresolvedEntitySet = _unresolvedEntitySet;
parameter._entitySetPathDefined = _entitySetPathDefined;
parameter._entitySet = _entitySet;
return parameter;
}
public TextElement(SchemaElement parentElement)
: base(parentElement)
{
}
internal void AddError(ErrorCode errorCode, EdmSchemaErrorSeverity severity, SchemaElement element, object message)
{
AddError(errorCode, severity, element.Schema.Location, element.LineNumber, element.LinePosition, message);
}
