/// <summary>
/// Resolves this managed collection at runtime.
/// </summary>
/// <param name="objectName">
/// The name of the top level object that is having the value of one of it's
/// collection properties resolved.
/// </param>
/// <param name="definition">
/// The definition of the named top level object.
/// </param>
/// <param name="propertyName">
/// The name of the property the value of which is being resolved.
/// </param>
/// <param name="resolver">
/// The callback that will actually do the donkey work of resolving
/// this managed collection.
/// </param>
/// <returns>A fully resolved collection.</returns>
public ICollection Resolve(string objectName, IObjectDefinition definition, string propertyName, ManagedCollectionElementResolver resolver)
{
IList list;
Type elementType = null;
if (StringUtils.HasText(this.elementTypeName))
{
elementType = TypeResolutionUtils.ResolveType(this.elementTypeName);
}
#if NET_2_0
if (elementType == null)
{
list = new ArrayList();
}
else
{
// CLOVER:ON
Type type = typeof(List<>);
Type[] genericArgs = new Type[1] { elementType };
type = type.MakeGenericType(genericArgs);
list = (IList)ObjectUtils.InstantiateType(type);
// CLOVER:OFF
}
#else
list = new ArrayList();
#endif
for (int i = 0; i < Count; ++i)
{
object element = this[i];
object resolvedElement =
resolver(objectName, definition, String.Format(CultureInfo.InvariantCulture, "{0}[{1}]", propertyName, i), element);
if (elementType != null)
{
try
{
resolvedElement = TypeConversionUtils.ConvertValueIfNecessary(elementType, resolvedElement, propertyName + "[" + i + "]");
}
catch (TypeMismatchException)
{
throw new TypeMismatchException(
String.Format(
"Unable to convert managed list element '{0}' from [{1}] into [{2}] during initialization"
+ " of property '{3}' for object '{4}'. Do you have an appropriate type converter registered?",
resolvedElement, resolvedElement.GetType(), elementType, propertyName, objectName));
}
}
list.Add(resolvedElement);
}
return list;
}
/// <summary>
/// Resolves this managed collection at runtime.
/// </summary>
/// <param name="objectName">
/// The name of the top level object that is having the value of one of it's
/// collection properties resolved.
/// </param>
/// <param name="definition">
/// The definition of the named top level object.
/// </param>
/// <param name="propertyName">
/// The name of the property the value of which is being resolved.
/// </param>
/// <param name="resolver">
/// The callback that will actually do the donkey work of resolving
/// this managed collection.
/// </param>
/// <returns>A fully resolved collection.</returns>
public ICollection Resolve(string objectName, IObjectDefinition definition, string propertyName, ManagedCollectionElementResolver resolver)
{
IList list;
Type elementType = null;
if (StringUtils.HasText(this.elementTypeName))
{
elementType = TypeResolutionUtils.ResolveType(this.elementTypeName);
}
if (elementType == null)
{
list = new ArrayList();
}
else
{
// CLOVER:ON
Type type = typeof(List <>);
Type[] genericArgs = new Type[1] {
elementType
};
type = type.MakeGenericType(genericArgs);
list = (IList)ObjectUtils.InstantiateType(type);
// CLOVER:OFF
}
for (int i = 0; i < Count; ++i)
{
object element = this[i];
object resolvedElement =
resolver(objectName, definition, String.Format(CultureInfo.InvariantCulture, "{0}[{1}]", propertyName, i), element);
if (elementType != null)
{
try
{
resolvedElement = TypeConversionUtils.ConvertValueIfNecessary(elementType, resolvedElement, propertyName + "[" + i + "]");
}
catch (TypeMismatchException)
{
throw new TypeMismatchException(
String.Format(
"Unable to convert managed list element '{0}' from [{1}] into [{2}] during initialization"
+ " of property '{3}' for object '{4}'. Do you have an appropriate type converter registered?",
resolvedElement, resolvedElement.GetType(), elementType, propertyName, objectName));
}
}
list.Add(resolvedElement);
}
return(list);
}
/// <summary>
/// Resolves this managed collection at runtime.
/// </summary>
/// <param name="objectName">
/// The name of the top level object that is having the value of one of it's
/// collection properties resolved.
/// </param>
/// <param name="definition">
/// The definition of the named top level object.
/// </param>
/// <param name="propertyName">
/// The name of the property the value of which is being resolved.
/// </param>
/// <param name="resolver">
/// The callback that will actually do the donkey work of resolving
/// this managed collection.
/// </param>
/// <returns>A fully resolved collection.</returns>
public ICollection Resolve(
string objectName, IObjectDefinition definition,
string propertyName, ManagedCollectionElementResolver resolver)
{
IDictionary dictionary;
Type keyType = null;
if (StringUtils.HasText(this.keyTypeName))
{
keyType = TypeResolutionUtils.ResolveType(this.keyTypeName);
}
Type valueType = null;
if (StringUtils.HasText(this.valueTypeName))
{
valueType = TypeResolutionUtils.ResolveType(this.valueTypeName);
}
if ((keyType == null) && (valueType == null))
{
dictionary = new HybridDictionary();
}
else
{
Type type = typeof(Dictionary <,>);
Type[] genericArgs = new Type[2] {
(keyType == null) ? typeof(object) : keyType,
(valueType == null) ? typeof(object) : valueType
};
type = type.MakeGenericType(genericArgs);
dictionary = (IDictionary)ObjectUtils.InstantiateType(type);
}
foreach (object key in this.Keys)
{
string elementName = string.Format(CultureInfo.InvariantCulture, "{0}[{1}]", propertyName, key);
object resolvedKey = resolver(objectName, definition, elementName, key);
object resolvedValue = resolver(objectName, definition, elementName, this[key]);
if (keyType != null)
{
try
{
resolvedKey = TypeConversionUtils.ConvertValueIfNecessary(keyType, resolvedKey, propertyName);
}
catch (TypeMismatchException)
{
throw new TypeMismatchException(
String.Format(
"Unable to convert managed dictionary key '{0}' from [{1}] into [{2}] during initialization"
+ " of property '{3}' for object '{4}'. Do you have an appropriate type converter registered?",
resolvedKey, resolvedKey.GetType(), keyType, propertyName, objectName));
}
}
if (valueType != null)
{
try
{
resolvedValue = TypeConversionUtils.ConvertValueIfNecessary(valueType, resolvedValue, propertyName + "[" + resolvedKey + "]");
}
catch (TypeMismatchException)
{
throw new TypeMismatchException(
String.Format(
"Unable to convert managed dictionary value '{0}' from [{1}] into [{2}] during initialization"
+ " of property '{3}' for object '{4}'. Do you have an appropriate type converter registered?",
resolvedValue, resolvedValue.GetType(), valueType, propertyName, objectName));
}
}
dictionary.Add(resolvedKey, resolvedValue);
}
return(dictionary);
}
/// <summary>
/// Resolves this managed collection at runtime.
/// </summary>
/// <param name="objectName">
/// The name of the top level object that is having the value of one of it's
/// collection properties resolved.
/// </param>
/// <param name="definition">
/// The definition of the named top level object.
/// </param>
/// <param name="propertyName">
/// The name of the property the value of which is being resolved.
/// </param>
/// <param name="resolver">
/// The callback that will actually do the donkey work of resolving
/// this managed collection.
/// </param>
/// <returns>A fully resolved collection.</returns>
public ICollection Resolve(
string objectName, IObjectDefinition definition,
string propertyName, ManagedCollectionElementResolver resolver)
{
IDictionary dictionary;
Type keyType = null;
if (StringUtils.HasText(this.keyTypeName))
{
keyType = TypeResolutionUtils.ResolveType(this.keyTypeName);
}
Type valueType = null;
if (StringUtils.HasText(this.valueTypeName))
{
valueType = TypeResolutionUtils.ResolveType(this.valueTypeName);
}
if ((keyType == null) && (valueType == null))
{
dictionary = new HybridDictionary();
}
else
{
Type type = typeof(Dictionary<,>);
Type[] genericArgs = new Type[2] {
(keyType == null) ? typeof(object) : keyType,
(valueType == null) ? typeof(object) : valueType };
type = type.MakeGenericType(genericArgs);
dictionary = (IDictionary)ObjectUtils.InstantiateType(type);
}
foreach (object key in this.Keys)
{
string elementName = string.Format(CultureInfo.InvariantCulture, "{0}[{1}]", propertyName, key);
object resolvedKey = resolver(objectName, definition, elementName, key);
object resolvedValue = resolver(objectName, definition, elementName, this[key]);
if (keyType != null)
{
try
{
resolvedKey = TypeConversionUtils.ConvertValueIfNecessary(keyType, resolvedKey, propertyName);
}
catch (TypeMismatchException)
{
throw new TypeMismatchException(
String.Format(
"Unable to convert managed dictionary key '{0}' from [{1}] into [{2}] during initialization"
+ " of property '{3}' for object '{4}'. Do you have an appropriate type converter registered?",
resolvedKey, resolvedKey.GetType(), keyType, propertyName, objectName));
}
}
if (valueType != null)
{
try
{
resolvedValue = TypeConversionUtils.ConvertValueIfNecessary(valueType, resolvedValue, propertyName + "[" + resolvedKey + "]");
}
catch (TypeMismatchException)
{
throw new TypeMismatchException(
String.Format(
"Unable to convert managed dictionary value '{0}' from [{1}] into [{2}] during initialization"
+ " of property '{3}' for object '{4}'. Do you have an appropriate type converter registered?",
resolvedValue, resolvedValue.GetType(), valueType, propertyName, objectName));
}
}
dictionary.Add(resolvedKey, resolvedValue);
}
return dictionary;
}
/// <summary>
/// Resolves this managed collection at runtime.
/// </summary>
/// <param name="objectName">
/// The name of the top level object that is having the value of one of it's
/// collection properties resolved.
/// </param>
/// <param name="definition">
/// The definition of the named top level object.
/// </param>
/// <param name="propertyName">
/// The name of the property the value of which is being resolved.
/// </param>
/// <param name="resolver">
/// The callback that will actually do the donkey work of resolving
/// this managed collection.
/// </param>
/// <returns>A fully resolved collection.</returns>
public ICollection Resolve(string objectName, IObjectDefinition definition, string propertyName, ManagedCollectionElementResolver resolver)
{
ISet set = new HybridSet();
Type elementType = null;
if (StringUtils.HasText(this.elementTypeName))
{
elementType = TypeResolutionUtils.ResolveType(this.elementTypeName);
}
string elementName = propertyName + "[(set-element)]";
foreach (object element in this)
{
object resolvedElement = resolver(objectName, definition, elementName, element);
if (elementType != null)
{
try
{
resolvedElement = TypeConversionUtils.ConvertValueIfNecessary(elementType, resolvedElement, propertyName);
}
catch (TypeMismatchException)
{
throw new TypeMismatchException(
String.Format(
"Unable to convert managed set element '{0}' from [{1}] into [{2}] during initialization"
+ " of property '{3}' for object '{4}'. Do you have an appropriate type converter registered?",
resolvedElement, resolvedElement.GetType(), elementType, propertyName, objectName));
}
}
set.Add(resolvedElement);
}
return set;
}
/// <summary>
/// Resolves this managed collection at runtime.
/// </summary>
/// <param name="objectName">
/// The name of the top level object that is having the value of one of it's
/// collection properties resolved.
/// </param>
/// <param name="definition">
/// The definition of the named top level object.
/// </param>
/// <param name="propertyName">
/// The name of the property the value of which is being resolved.
/// </param>
/// <param name="resolver">
/// The callback that will actually do the donkey work of resolving
/// this managed collection.
/// </param>
/// <returns>A fully resolved collection.</returns>
public ICollection Resolve(string objectName, IObjectDefinition definition, string propertyName, ManagedCollectionElementResolver resolver)
{
ISet set = new HybridSet();
Type elementType = null;
if (StringUtils.HasText(this.elementTypeName))
{
elementType = TypeResolutionUtils.ResolveType(this.elementTypeName);
}
string elementName = propertyName + "[(set-element)]";
foreach (object element in this)
{
object resolvedElement = resolver(objectName, definition, elementName, element);
if (elementType != null)
{
try
{
resolvedElement = TypeConversionUtils.ConvertValueIfNecessary(elementType, resolvedElement, propertyName);
}
catch (TypeMismatchException)
{
throw new TypeMismatchException(
String.Format(
"Unable to convert managed set element '{0}' from [{1}] into [{2}] during initialization"
+ " of property '{3}' for object '{4}'. Do you have an appropriate type converter registered?",
resolvedElement, resolvedElement.GetType(), elementType, propertyName, objectName));
}
}
set.Add(resolvedElement);
}
return(set);
}
public ICollection Resolve(string objectName, IObjectDefinition definition, string propertyName, ManagedCollectionElementResolver resolver)
{
throw new NotImplementedException();
}
public ICollection Resolve(string objectName, IObjectDefinition definition, string propertyName, ManagedCollectionElementResolver resolver)
{
throw new NotImplementedException();
}