/// <summary>
/// Adds a collection of items to the collection
/// </summary>
/// <param name="items"> The items to add to the list </param>
/// <exception cref="System.ArgumentNullException">Thrown if item argument is null</exception>
/// <exception cref="System.InvalidOperationException">Thrown if the item passed in or the collection itself instance is in ReadOnly state</exception>
/// <exception cref="System.ArgumentException">Thrown if the item that is being added already belongs to another ItemCollection</exception>
/// <exception cref="System.ArgumentException">Thrown if the ItemCollection already contains an item with the same identity</exception>
/// <returns> Whether the add was successful </returns>
internal bool AtomicAddRange(List <T> items)
{
var originalData = _collectionData;
var newData = new CollectionData(originalData, items.Count);
// Add the new items, this will also perform duplication check
foreach (var item in items)
{
if (item == null)
{
throw new ArgumentException(Strings.ADP_CollectionParameterElementIsNull("items"));
}
Debug.Assert(!String.IsNullOrEmpty(item.Identity), "Identity of the item must never be null or empty");
AddInternalHelper(item, newData, false);
}
var swappedOutData = Interlocked.CompareExchange(ref _collectionData, newData, originalData);
// Check if the exchange was done, if not, then someone must have changed the data in the meantime, so
// return false
if (swappedOutData != originalData)
{
return(false);
}
return(true);
}
internal static void CheckAndAddMembers(IEnumerable <EdmMember> members, EntityType entityType)
{
foreach (EdmMember member in members)
{
if (member == null)
{
throw new ArgumentException(Strings.ADP_CollectionParameterElementIsNull((object)nameof(members)));
}
entityType.AddMember(member);
}
}
internal void AddRange(List <T> items)
{
Check.NotNull <List <T> >(items, nameof(items));
foreach (T obj in items)
{
if ((object)obj == null)
{
throw new ArgumentException(Strings.ADP_CollectionParameterElementIsNull((object)nameof(items)));
}
this.AddInternal(obj);
}
}
public void AddRange_throws_ArgumentNullException_for_null_collection_item()
{
var metadataCollection = new MetadataCollection <MetadataItem>();
Assert.Equal(
Strings.ADP_CollectionParameterElementIsNull("items"),
Assert.Throws <ArgumentException>(
() => metadataCollection.AddRange(
new List <MetadataItem>
{
null
})).Message);
}
public void Constructor_throws_ArgumentException_for_null_collection_item()
{
var items = new[]
{
new EntityType("E0", "N", DataSpace.CSpace),
null,
new EntityType("E2", "N", DataSpace.CSpace)
};
Assert.Equal(
Strings.ADP_CollectionParameterElementIsNull("items"),
Assert.Throws <ArgumentException>(() => new MetadataCollection <MetadataItem>(items)).Message);
}
// <summary>
// Adds the specified items to the collection.
// </summary>
// <param name="items">The items to add to the collection.</param>
// <exception cref="System.ArgumentException">An item to add is null.</exception>
// <exception cref="System.ArgumentException">An item with the same identity already exists.</exception>
// <returns>A boolean that indicates whether the operation was successful.</returns>
internal void AddRange(IEnumerable <T> items)
{
Check.NotNull(items, "items");
// Add the new items, this will also perform duplication check.
foreach (var item in items)
{
if (item == null)
{
throw new ArgumentException(Strings.ADP_CollectionParameterElementIsNull("items"));
}
AddInternal(item);
}
}
public static MetadataArtifactLoader CreateCompositeFromXmlReaders(
IEnumerable <XmlReader> xmlReaders)
{
List <MetadataArtifactLoader> allCollections = new List <MetadataArtifactLoader>();
foreach (XmlReader xmlReader in xmlReaders)
{
if (xmlReader == null)
{
throw new ArgumentException(Strings.ADP_CollectionParameterElementIsNull((object)nameof(xmlReaders)));
}
allCollections.Add((MetadataArtifactLoader) new MetadataArtifactLoaderXmlReaderWrapper(xmlReader));
}
return(MetadataArtifactLoader.Create(allCollections));
}
// <summary>
// Helper method that wraps a collection of XmlReader objects in MetadataArtifactLoader
// instances.
// </summary>
// <param name="xmlReaders"> The collection of XmlReader objects to wrap </param>
// <returns> An instance of MetadataArtifactLoader </returns>
public static MetadataArtifactLoader CreateCompositeFromXmlReaders(IEnumerable <XmlReader> xmlReaders)
{
var loaders = new List <MetadataArtifactLoader>();
foreach (var reader in xmlReaders)
{
if (reader == null)
{
throw new ArgumentException(Strings.ADP_CollectionParameterElementIsNull("xmlReaders"));
}
loaders.Add(new MetadataArtifactLoaderXmlReaderWrapper(reader));
}
return(Create(loaders));
}
/// <summary>
/// Checks for each property to be non-null and then adds it to the member collection
/// </summary>
/// <param name="members"> members for this type </param>
/// <param name="entityType"> the membersCollection to which the members should be added </param>
internal static void CheckAndAddMembers(
IEnumerable <EdmMember> members,
EntityType entityType)
{
foreach (var member in members)
{
// Check for each property to be non-null
if (null == member)
{
throw new ArgumentException(Strings.ADP_CollectionParameterElementIsNull("members"));
}
// Add the property to the member collection
entityType.AddMember(member);
}
}
internal MetadataCollection(IEnumerable <T> items)
{
this._metadataList = new List <T>();
if (items == null)
{
return;
}
foreach (T obj in items)
{
if ((object)obj == null)
{
throw new ArgumentException(Strings.ADP_CollectionParameterElementIsNull((object)nameof(items)));
}
this.AddInternal(obj);
}
}
internal void CheckAndAddKeyMembers(IEnumerable <string> keyMembers)
{
foreach (string keyMember in keyMembers)
{
if (keyMember == null)
{
throw new ArgumentException(Strings.ADP_CollectionParameterElementIsNull((object)nameof(keyMembers)));
}
EdmMember member;
if (!this.Members.TryGetValue(keyMember, false, out member))
{
throw new ArgumentException(Strings.InvalidKeyMember((object)keyMember));
}
this.AddKeyMember(member);
}
}
/// <summary>
/// The constructor for constructing the collection with the given items
/// </summary>
/// <param name="items"> The items to populate the collection </param>
internal MetadataCollection(IEnumerable <T> items)
{
_collectionData = new CollectionData();
if (items != null)
{
foreach (var item in items)
{
if (item == null)
{
throw new ArgumentException(Strings.ADP_CollectionParameterElementIsNull("items"));
}
Debug.Assert(!String.IsNullOrEmpty(item.Identity), "Identity of the item must never be null or empty");
AddInternal(item);
}
}
}
private static IEnumerable <EdmProperty> CheckProperties(
IEnumerable <EdmProperty> properties)
{
if (properties != null)
{
int num = 0;
foreach (EdmProperty property in properties)
{
if (property == null)
{
throw new ArgumentException(Strings.ADP_CollectionParameterElementIsNull((object)nameof(properties)));
}
++num;
}
}
return(properties);
}
// <summary>
// Creates a metadata collection that contains the specified items.
// The items are copied into an internal list.
// </summary>
// <param name="items">An enumerable of items to be stored in the collection.</param>
internal MetadataCollection(IEnumerable <T> items)
{
_metadataList = new List <T>();
if (items != null)
{
foreach (var item in items)
{
if (item == null)
{
throw new ArgumentException(Strings.ADP_CollectionParameterElementIsNull("items"));
}
AddInternal(item);
}
}
}
/// <summary>
/// Checks for each key member to be non-null
/// also check for it to be present in the members collection
/// and then adds it to the KeyMembers collection.
/// Throw if the key member is not already in the members
/// collection. Cannot do much other than that as the
/// Key members is just an Ienumerable of the names
/// of the members.
/// </summary>
/// <param name="keyMembers"> the list of keys (member names) to be added for the given type </param>
internal void CheckAndAddKeyMembers(IEnumerable <String> keyMembers)
{
foreach (var keyMember in keyMembers)
{
// Check for each keymember to be non-null
if (null == keyMember)
{
throw new ArgumentException(Strings.ADP_CollectionParameterElementIsNull("keyMembers"));
}
// Check for whether the key exists in the members collection
EdmMember member;
if (!Members.TryGetValue(keyMember, false, out member))
{
throw new ArgumentException(Strings.InvalidKeyMember(keyMember));
//--- to do, identify the right exception to throw here
}
// Add the key member to the key member collection
AddKeyMember(member);
}
}
private static IEnumerable <EdmProperty> CheckProperties(IEnumerable <EdmProperty> properties)
{
if (null != properties)
{
var i = 0;
foreach (var prop in properties)
{
if (prop == null)
{
throw new ArgumentException(Strings.ADP_CollectionParameterElementIsNull("properties"));
}
i++;
}
/*
* if (i < 1)
* {
* throw EntityUtil.ArgumentOutOfRange("properties");
* }
*/
}
return(properties);
}
internal EdmFunction(
string name,
string namespaceName,
DataSpace dataSpace,
EdmFunctionPayload payload)
: base(name, namespaceName, dataSpace)
{
this._schemaName = payload.Schema;
IList <FunctionParameter> source = payload.ReturnParameters ?? (IList <FunctionParameter>) new FunctionParameter[0];
foreach (FunctionParameter functionParameter in (IEnumerable <FunctionParameter>)source)
{
if (functionParameter == null)
{
throw new ArgumentException(Strings.ADP_CollectionParameterElementIsNull((object)nameof(ReturnParameters)));
}
if (functionParameter.Mode != ParameterMode.ReturnValue)
{
throw new ArgumentException(Strings.NonReturnParameterInReturnParameterCollection);
}
}
this._returnParameters = new ReadOnlyMetadataCollection <FunctionParameter>(source.Select <FunctionParameter, FunctionParameter>((Func <FunctionParameter, FunctionParameter>)(returnParameter => SafeLink <EdmFunction> .BindChild <FunctionParameter>(this, FunctionParameter.DeclaringFunctionLinker, returnParameter))).ToList <FunctionParameter>());
if (payload.IsAggregate.HasValue)
{
EdmFunction.SetFunctionAttribute(ref this._functionAttributes, EdmFunction.FunctionAttributes.Aggregate, payload.IsAggregate.Value);
}
if (payload.IsBuiltIn.HasValue)
{
EdmFunction.SetFunctionAttribute(ref this._functionAttributes, EdmFunction.FunctionAttributes.BuiltIn, payload.IsBuiltIn.Value);
}
if (payload.IsNiladic.HasValue)
{
EdmFunction.SetFunctionAttribute(ref this._functionAttributes, EdmFunction.FunctionAttributes.NiladicFunction, payload.IsNiladic.Value);
}
if (payload.IsComposable.HasValue)
{
EdmFunction.SetFunctionAttribute(ref this._functionAttributes, EdmFunction.FunctionAttributes.IsComposable, payload.IsComposable.Value);
}
if (payload.IsFromProviderManifest.HasValue)
{
EdmFunction.SetFunctionAttribute(ref this._functionAttributes, EdmFunction.FunctionAttributes.IsFromProviderManifest, payload.IsFromProviderManifest.Value);
}
if (payload.IsCachedStoreFunction.HasValue)
{
EdmFunction.SetFunctionAttribute(ref this._functionAttributes, EdmFunction.FunctionAttributes.IsCachedStoreFunction, payload.IsCachedStoreFunction.Value);
}
if (payload.IsFunctionImport.HasValue)
{
EdmFunction.SetFunctionAttribute(ref this._functionAttributes, EdmFunction.FunctionAttributes.IsFunctionImport, payload.IsFunctionImport.Value);
}
if (payload.ParameterTypeSemantics.HasValue)
{
this._parameterTypeSemantics = payload.ParameterTypeSemantics.Value;
}
if (payload.StoreFunctionName != null)
{
this._storeFunctionNameAttribute = payload.StoreFunctionName;
}
if (payload.EntitySets != null)
{
if (payload.EntitySets.Count != source.Count)
{
throw new ArgumentException(Strings.NumberOfEntitySetsDoesNotMatchNumberOfReturnParameters);
}
this._entitySets = new ReadOnlyCollection <EntitySet>(payload.EntitySets);
}
else
{
if (this._returnParameters.Count > 1)
{
throw new ArgumentException(Strings.NullEntitySetsForFunctionReturningMultipleResultSets);
}
this._entitySets = new ReadOnlyCollection <EntitySet>((IList <EntitySet>) this._returnParameters.Select <FunctionParameter, EntitySet>((Func <FunctionParameter, EntitySet>)(p => (EntitySet)null)).ToList <EntitySet>());
}
if (payload.CommandText != null)
{
this._commandTextAttribute = payload.CommandText;
}
if (payload.Parameters != null)
{
foreach (FunctionParameter parameter in (IEnumerable <FunctionParameter>)payload.Parameters)
{
if (parameter == null)
{
throw new ArgumentException(Strings.ADP_CollectionParameterElementIsNull((object)"parameters"));
}
if (parameter.Mode == ParameterMode.ReturnValue)
{
throw new ArgumentException(Strings.ReturnParameterInInputParameterCollection);
}
}
this._parameters = (ReadOnlyMetadataCollection <FunctionParameter>) new SafeLinkCollection <EdmFunction, FunctionParameter>(this, FunctionParameter.DeclaringFunctionLinker, new MetadataCollection <FunctionParameter>((IEnumerable <FunctionParameter>)payload.Parameters));
}
else
{
this._parameters = new ReadOnlyMetadataCollection <FunctionParameter>(new MetadataCollection <FunctionParameter>());
}
}
internal EdmFunction(string name, string namespaceName, DataSpace dataSpace, EdmFunctionPayload payload)
: base(name, namespaceName, dataSpace)
{
//---- name of the 'schema'
//---- this is used by the SQL Gen utility and update pipeline to support generation of the correct function name in the store
_schemaName = payload.Schema;
var returnParameters = payload.ReturnParameters ?? new FunctionParameter[0];
foreach (var returnParameter in returnParameters)
{
if (returnParameter == null)
{
throw new ArgumentException(Strings.ADP_CollectionParameterElementIsNull("ReturnParameters"));
}
if (returnParameter.Mode != ParameterMode.ReturnValue)
{
throw new ArgumentException(Strings.NonReturnParameterInReturnParameterCollection);
}
}
_returnParameters = new ReadOnlyMetadataCollection <FunctionParameter>(
returnParameters
.Select(
returnParameter =>
SafeLink <EdmFunction> .BindChild(this, FunctionParameter.DeclaringFunctionLinker, returnParameter))
.ToList());
if (payload.IsAggregate.HasValue)
{
SetFunctionAttribute(ref _functionAttributes, FunctionAttributes.Aggregate, payload.IsAggregate.Value);
}
if (payload.IsBuiltIn.HasValue)
{
SetFunctionAttribute(ref _functionAttributes, FunctionAttributes.BuiltIn, payload.IsBuiltIn.Value);
}
if (payload.IsNiladic.HasValue)
{
SetFunctionAttribute(ref _functionAttributes, FunctionAttributes.NiladicFunction, payload.IsNiladic.Value);
}
if (payload.IsComposable.HasValue)
{
SetFunctionAttribute(ref _functionAttributes, FunctionAttributes.IsComposable, payload.IsComposable.Value);
}
if (payload.IsFromProviderManifest.HasValue)
{
SetFunctionAttribute(
ref _functionAttributes, FunctionAttributes.IsFromProviderManifest, payload.IsFromProviderManifest.Value);
}
if (payload.IsCachedStoreFunction.HasValue)
{
SetFunctionAttribute(ref _functionAttributes, FunctionAttributes.IsCachedStoreFunction, payload.IsCachedStoreFunction.Value);
}
if (payload.IsFunctionImport.HasValue)
{
SetFunctionAttribute(ref _functionAttributes, FunctionAttributes.IsFunctionImport, payload.IsFunctionImport.Value);
}
if (payload.ParameterTypeSemantics.HasValue)
{
_parameterTypeSemantics = payload.ParameterTypeSemantics.Value;
}
if (payload.StoreFunctionName != null)
{
_storeFunctionNameAttribute = payload.StoreFunctionName;
}
if (payload.EntitySets != null)
{
if (payload.EntitySets.Count != returnParameters.Count)
{
throw new ArgumentException(Strings.NumberOfEntitySetsDoesNotMatchNumberOfReturnParameters);
}
_entitySets = new ReadOnlyCollection <EntitySet>(payload.EntitySets);
}
else
{
if (_returnParameters.Count > 1)
{
throw new ArgumentException(Strings.NullEntitySetsForFunctionReturningMultipleResultSets);
}
_entitySets = new ReadOnlyCollection <EntitySet>(_returnParameters.Select(p => (EntitySet)null).ToList());
}
if (payload.CommandText != null)
{
_commandTextAttribute = payload.CommandText;
}
if (payload.Parameters != null)
{
// validate the parameters
foreach (var parameter in payload.Parameters)
{
if (parameter == null)
{
throw new ArgumentException(Strings.ADP_CollectionParameterElementIsNull("parameters"));
}
if (parameter.Mode == ParameterMode.ReturnValue)
{
throw new ArgumentException(Strings.ReturnParameterInInputParameterCollection);
}
}
// Populate the parameters
_parameters = new SafeLinkCollection <EdmFunction, FunctionParameter>(
this, FunctionParameter.DeclaringFunctionLinker, new MetadataCollection <FunctionParameter>(payload.Parameters));
}
else
{
_parameters = new ReadOnlyMetadataCollection <FunctionParameter>(new MetadataCollection <FunctionParameter>());
}
}
internal EdmFunction(string name, string namespaceName, DataSpace dataSpace, EdmFunctionPayload payload)
: base(name, namespaceName, dataSpace)
{
//---- name of the 'schema'
//---- this is used by the SQL Gen utility and update pipeline to support generation of the correct function name in the store
_schemaName = payload.Schema;
_fullName = NamespaceName + "." + Name;
var returnParameters = payload.ReturnParameters;
Debug.Assert(returnParameters.All((returnParameter) => returnParameter != null), "All return parameters must be non-null");
Debug.Assert(
returnParameters.All((returnParameter) => returnParameter.Mode == ParameterMode.ReturnValue),
"Return parameter in a function must have the ParameterMode equal to ReturnValue.");
_returnParameters = new ReadOnlyMetadataCollection <FunctionParameter>(
returnParameters
.Select(
(returnParameter) =>
SafeLink <EdmFunction> .BindChild(this, FunctionParameter.DeclaringFunctionLinker, returnParameter))
.ToList());
if (payload.IsAggregate.HasValue)
{
SetFunctionAttribute(ref _functionAttributes, FunctionAttributes.Aggregate, payload.IsAggregate.Value);
}
if (payload.IsBuiltIn.HasValue)
{
SetFunctionAttribute(ref _functionAttributes, FunctionAttributes.BuiltIn, payload.IsBuiltIn.Value);
}
if (payload.IsNiladic.HasValue)
{
SetFunctionAttribute(ref _functionAttributes, FunctionAttributes.NiladicFunction, payload.IsNiladic.Value);
}
if (payload.IsComposable.HasValue)
{
SetFunctionAttribute(ref _functionAttributes, FunctionAttributes.IsComposable, payload.IsComposable.Value);
}
if (payload.IsFromProviderManifest.HasValue)
{
SetFunctionAttribute(
ref _functionAttributes, FunctionAttributes.IsFromProviderManifest, payload.IsFromProviderManifest.Value);
}
if (payload.IsCachedStoreFunction.HasValue)
{
SetFunctionAttribute(ref _functionAttributes, FunctionAttributes.IsCachedStoreFunction, payload.IsCachedStoreFunction.Value);
}
if (payload.IsFunctionImport.HasValue)
{
SetFunctionAttribute(ref _functionAttributes, FunctionAttributes.IsFunctionImport, payload.IsFunctionImport.Value);
}
if (payload.ParameterTypeSemantics.HasValue)
{
_parameterTypeSemantics = payload.ParameterTypeSemantics.Value;
}
if (payload.StoreFunctionName != null)
{
_storeFunctionNameAttribute = payload.StoreFunctionName;
}
if (payload.EntitySets != null)
{
Debug.Assert(
_returnParameters.Count == payload.EntitySets.Length,
"The number of entity sets should match the number of return parameters");
_entitySets = new ReadOnlyMetadataCollection <EntitySet>(payload.EntitySets);
}
else
{
var list = new List <EntitySet>();
if (_returnParameters.Count != 0)
{
Debug.Assert(
_returnParameters.Count == 1, "If there was more than one result set payload.EntitySets should not have been null");
list.Add(null);
}
_entitySets = new ReadOnlyMetadataCollection <EntitySet>(list);
}
if (payload.CommandText != null)
{
_commandTextAttribute = payload.CommandText;
}
if (payload.Parameters != null)
{
// validate the parameters
foreach (var parameter in payload.Parameters)
{
if (parameter == null)
{
throw new ArgumentException(Strings.ADP_CollectionParameterElementIsNull("parameters"));
}
Debug.Assert(
parameter.Mode != ParameterMode.ReturnValue, "No function parameter can have ParameterMode equal to ReturnValue.");
}
// Populate the parameters
_parameters = new SafeLinkCollection <EdmFunction, FunctionParameter>(
this, FunctionParameter.DeclaringFunctionLinker, new MetadataCollection <FunctionParameter>(payload.Parameters));
}
else
{
_parameters = new ReadOnlyMetadataCollection <FunctionParameter>(new MetadataCollection <FunctionParameter>());
}
}