#region License
/*
* Copyright 2002-2007 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#endregion
using System;
using Spring.Core;
using Spring.Core.TypeResolution;
namespace Spring.Objects.Factory.Config{
/// <summary>
/// Base class that provides common functionality needed for several IObjectFactoryPostProcessor
/// implementations
/// </summary>
/// <author>Mark Pollack</author>
[Serializable]
public abstract class AbstractConfigurer : IOrdered, IObjectFactoryPostProcessor
{
private int order = Int32.MaxValue; // default: same as non-Ordered
/// <summary>
/// Return the order value of this object, with a higher value meaning
/// greater in terms of sorting.
/// </summary>
/// <returns>The order value.</returns>
/// <seealso cref="Spring.Core.IOrdered.Order"/>
public int Order
{
get { return order; }
set { order = value; }
}
/// <summary>
/// Modify the application context's internal object factory after its
/// standard initialization.
/// </summary>
/// <param name="factory">The object factory used by the application context.</param>
/// <remarks>
/// <p>
/// All object definitions will have been loaded, but no objects will have
/// been instantiated yet. This allows for overriding or adding properties
/// even to eager-initializing objects.
/// </p>
/// </remarks>
/// <exception cref="Spring.Objects.ObjectsException">
/// In case of errors.
/// </exception>
public abstract void PostProcessObjectFactory(
IConfigurableListableObjectFactory factory);
/// <summary>
/// Resolves the supplied <paramref name="value"/> into a
/// <see cref="System.Type"/> instance.
/// </summary>
/// <param name="value">The object that is to be resolved into a <see cref="System.Type"/>
/// instance.</param>
/// <param name="errorContextSource">The error context source.</param>
/// <param name="errorContext">The error context string.</param>
/// <returns>A resolved <see cref="System.Type"/>.</returns>
/// <remarks>
/// <p>
/// This (default) implementation supports resolving
/// <see cref="System.String"/>s and <see cref="System.Type"/>s.
/// Only override this method if you want to key your type alias
/// on something other than <see cref="System.String"/>s
/// and <see cref="System.Type"/>s.
/// </p>
/// </remarks>
/// <exception cref="Spring.Objects.ObjectsException">
/// If the supplied <paramref name="value"/> is <see langword="null"/>,
/// or the supplied <paramref name="value"/> cannot be resolved.
/// </exception>
protected virtual Type ResolveRequiredType(object value, string errorContextSource, string errorContext)
{
Type requiredType = value as Type;
if (requiredType == null)
{
string typeName = value as string;
if (typeName != null)
{
try
{
requiredType = TypeResolutionUtils.ResolveType(typeName);
}
catch (TypeLoadException ex)
{
throw new ObjectInitializationException(
string.Format(
"Could not load required type [{0}] for {1}.",
typeName, errorContext), ex);
}
}
else
{
throw new ObjectInitializationException(
string.Format(
"Invalid value '{0}' for {1} - " +
"must be a System.String or System.Type.",
value, errorContext));
}
}
return requiredType;
}
}
}
|