public void Add(T type, bool doNotAddErrorForEmptyName, Func <object, string> duplicateKeyErrorFormat)
{
Debug.Assert(type != null, "type parameter is null");
Debug.Assert(null != duplicateKeyErrorFormat, "duplicateKeyErrorFormat cannot be null");
AddErrorKind error = TryAdd(type);
if (error == AddErrorKind.MissingNameError)
{
if (!doNotAddErrorForEmptyName)
{
type.AddError(ErrorCode.InvalidName, EdmSchemaErrorSeverity.Error,
System.Data.Entity.Strings.MissingName);
}
return;
}
else if (error == AddErrorKind.DuplicateNameError)
{
type.AddError(ErrorCode.AlreadyDefined, EdmSchemaErrorSeverity.Error,
duplicateKeyErrorFormat(type.FQName));
}
else
{
Debug.Assert(error == AddErrorKind.Succeeded, "Invalid error encountered");
}
}
protected void AddFunctionType(Function function)
{
string space = DataModel == SchemaDataModelOption.EntityDataModel ? "Conceptual" : "Storage";
if (this.SchemaVersion >= XmlConstants.EdmVersionForV2 && this.SchemaManager.SchemaTypes.ContainsKey(function.FQName))
{
function.AddError(ErrorCode.AlreadyDefined, EdmSchemaErrorSeverity.Error,
System.Data.Entity.Strings.AmbiguousFunctionAndType(function.FQName, space));
}
else
{
AddErrorKind error = this.SchemaManager.SchemaTypes.TryAdd(function);
Debug.Assert(error != AddErrorKind.MissingNameError, "Function identity can never be null while adding global functions");
if (error != AddErrorKind.Succeeded)
{
function.AddError(ErrorCode.AlreadyDefined, EdmSchemaErrorSeverity.Error,
System.Data.Entity.Strings.AmbiguousFunctionOverload(function.FQName, space));
}
else
{
this.SchemaTypes.Add(function);
}
}
}
internal override void Validate()
{
if (this._isAlreadyValidated)
{
return;
}
base.Validate();
if (this.ExtendingEntityContainer != null)
{
this.ExtendingEntityContainer.Validate();
foreach (SchemaElement member in this.ExtendingEntityContainer.Members)
{
AddErrorKind error = this.Members.TryAdd(member.Clone((SchemaElement)this));
this.DuplicateOrEquivalentMemberNameWhileExtendingEntityContainer(member, error);
}
}
HashSet <string> tableKeys = new HashSet <string>();
foreach (SchemaElement member in this.Members)
{
EntityContainerEntitySet entitySet = member as EntityContainerEntitySet;
if (entitySet != null && this.Schema.DataModel == SchemaDataModelOption.ProviderDataModel)
{
this.CheckForDuplicateTableMapping(tableKeys, entitySet);
}
member.Validate();
}
this.ValidateRelationshipSetHaveUniqueEnds();
this.ValidateOnlyBaseEntitySetTypeDefinesConcurrency();
this._isAlreadyValidated = true;
}
private void DuplicateOrEquivalentMemberNameWhileExtendingEntityContainer(
SchemaElement schemaElement,
AddErrorKind error)
{
if (error == AddErrorKind.Succeeded)
{
return;
}
schemaElement.AddError(ErrorCode.AlreadyDefined, EdmSchemaErrorSeverity.Error, (object)Strings.DuplicateMemberNameInExtendedEntityContainer((object)schemaElement.Name, (object)this.ExtendingEntityContainer.Name, (object)this.Name));
}
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(this.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,
System.Data.Entity.Strings.DuplicateMemberNameInExtendedEntityContainer(
schemaElement.Name, ExtendingEntityContainer.Name, this.Name));
}
}
/// <summary>
/// Do all validation for this element here, and delegate to all sub elements
/// </summary>
internal override void Validate()
{
// Now before we clone all the entity sets from the entity container that this entity container is extending,
// we need to make sure that the entity container that is getting extended is already validated. since it might
// be extending some other entity container, and we might want to populate this entity container, before
// it gets extended
if (!_isAlreadyValidated)
{
base.Validate();
// If this entity container extends some other entity container, then we should add all the
// sets and function imports from that entity container to this entity container
if (this.ExtendingEntityContainer != null)
{
// Call Validate on the entity container that is getting extended, so that its entity set
// is populated
this.ExtendingEntityContainer.Validate();
foreach (SchemaElement element in this.ExtendingEntityContainer.Members)
{
AddErrorKind error = this.Members.TryAdd(element.Clone(this));
DuplicateOrEquivalentMemberNameWhileExtendingEntityContainer(element, error);
}
}
HashSet <string> tableKeys = new HashSet <string>();
foreach (SchemaElement element in Members)
{
EntityContainerEntitySet entitySet = element as EntityContainerEntitySet;
if (entitySet != null && Schema.DataModel == SchemaDataModelOption.ProviderDataModel)
{
CheckForDuplicateTableMapping(tableKeys, entitySet);
}
element.Validate();
}
ValidateRelationshipSetHaveUniqueEnds();
ValidateOnlyBaseEntitySetTypeDefinesConcurrency();
// Set isAlreadyValidated to true
_isAlreadyValidated = true;
}
}
protected void CloneSetFunctionFields(Function clone)
{
clone._isAggregate = _isAggregate;
clone._isBuiltIn = _isBuiltIn;
clone._isNiladicFunction = _isNiladicFunction;
clone._isComposable = _isComposable;
clone._commandText = _commandText;
clone._storeFunctionName = _storeFunctionName;
clone._type = _type;
clone._returnTypeList = _returnTypeList;
clone._returnTypeCollectionKind = _returnTypeCollectionKind;
clone._parameterTypeSemantics = _parameterTypeSemantics;
clone._schema = _schema;
clone.Name = this.Name;
// Clone all the parameters
foreach (Parameter parameter in this.Parameters)
{
AddErrorKind error = clone.Parameters.TryAdd((Parameter)parameter.Clone(clone));
Debug.Assert(error == AddErrorKind.Succeeded, "Since we are cloning a validated function, this should never fail.");
}
}
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(this.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,
System.Data.Entity.Strings.DuplicateMemberNameInExtendedEntityContainer(
schemaElement.Name, ExtendingEntityContainer.Name, this.Name));
}
}
