/// <summary>
/// Resolve the target type of the passed <see cref="TypedStringValue"/>.
/// </summary>
/// <param name="value">The <see cref="TypedStringValue"/> who's target type is to be resolved</param>
/// <returns>The resolved target type, if any. <see lang="null" /> otherwise.</returns>
protected virtual Type ResolveTargetType(TypedStringValue value)
{
if (value.HasTargetType)
{
return(value.TargetType);
}
return(value.ResolveTargetType());
}
/// <summary>
/// Resolve the target type of the passed <see cref="TypedStringValue"/>.
/// </summary>
/// <param name="value">The <see cref="TypedStringValue"/> who's target type is to be resolved</param>
/// <returns>The resolved target type, if any. <see lang="null" /> otherwise.</returns>
protected virtual Type ResolveTargetType(TypedStringValue value)
{
if (value.HasTargetType)
{
return(value.TargetType);
}
else
{
return(null);
}
}
/// <summary>The build typed string value.</summary>
/// <param name="value">The value.</param>
/// <param name="targetTypeName">The target type name.</param>
/// <returns>The Spring.Objects.Factory.Config.TypedStringValue.</returns>
protected TypedStringValue buildTypedStringValue(string value, string targetTypeName)
{
TypedStringValue typedValue;
if (!StringUtils.HasText(targetTypeName))
{
typedValue = new TypedStringValue(value);
}
else
{
var targetType = Type.GetType(targetTypeName);
if (targetType != null)
{
typedValue = new TypedStringValue(value, targetType);
}
else
{
typedValue = new TypedStringValue(value, targetTypeName);
}
}
return(typedValue);
}
/// <summary>
/// TODO
/// </summary>
/// <param name="name">
/// The name of the object that is having the value of one of its properties resolved.
/// </param>
/// <param name="definition">
/// The definition of the named object.
/// </param>
/// <param name="argumentName">
/// The name of the property the value of which is being resolved.
/// </param>
/// <param name="argumentValue">
/// The value of the property that is being resolved.
/// </param>
private object ResolvePropertyValue(string name, IObjectDefinition definition, string argumentName, object argumentValue)
{
object resolvedValue = null;
// we must check the argument value to see whether it requires a runtime
// reference to another object to be resolved.
// if it does, we'll attempt to instantiate the object and set the reference.
if (RemotingServices.IsTransparentProxy(argumentValue))
{
resolvedValue = argumentValue;
}
else if (argumentValue is ICustomValueReferenceHolder)
{
resolvedValue = ((ICustomValueReferenceHolder)argumentValue).Resolve(objectFactory, name, definition, argumentName, argumentValue);
}
else if (argumentValue is ObjectDefinitionHolder)
{
// contains an IObjectDefinition with name and aliases...
ObjectDefinitionHolder holder = (ObjectDefinitionHolder)argumentValue;
resolvedValue = ResolveInnerObjectDefinition(name, holder.ObjectName, argumentName, holder.ObjectDefinition, definition.IsSingleton);
}
else if (argumentValue is IObjectDefinition)
{
// resolve plain IObjectDefinition, without contained name: use dummy name...
IObjectDefinition def = (IObjectDefinition)argumentValue;
resolvedValue = ResolveInnerObjectDefinition(name, "(inner object)", argumentName, def, definition.IsSingleton);
}
else if (argumentValue is RuntimeObjectReference)
{
RuntimeObjectReference roref = (RuntimeObjectReference)argumentValue;
resolvedValue = ResolveReference(definition, name, argumentName, roref);
}
else if (argumentValue is ExpressionHolder)
{
ExpressionHolder expHolder = (ExpressionHolder)argumentValue;
object context = null;
IDictionary <string, object> variables = null;
if (expHolder.Properties != null)
{
PropertyValue contextProperty = expHolder.Properties.GetPropertyValue("Context");
context = contextProperty == null
? null
: ResolveValueIfNecessary(name, definition, "Context",
contextProperty.Value);
PropertyValue variablesProperty = expHolder.Properties.GetPropertyValue("Variables");
object vars = (variablesProperty == null
? null
: ResolveValueIfNecessary(name, definition, "Variables",
variablesProperty.Value));
if (vars is IDictionary <string, object> )
{
variables = (IDictionary <string, object>)vars;
}
if (vars is IDictionary)
{
IDictionary temp = (IDictionary)vars;
variables = new Dictionary <string, object>(temp.Count);
foreach (DictionaryEntry entry in temp)
{
variables.Add((string)entry.Key, entry.Value);
}
}
else
{
if (vars != null)
{
throw new ArgumentException("'Variables' must resolve to an IDictionary");
}
}
}
if (variables == null)
{
variables = new Dictionary <string, object>(StringComparer.OrdinalIgnoreCase);
}
// add 'this' objectfactory reference to variables
variables.Add(Expression.ReservedVariableNames.CurrentObjectFactory, objectFactory);
resolvedValue = expHolder.Expression.GetValue(context, variables);
}
else if (argumentValue is IManagedCollection)
{
resolvedValue =
((IManagedCollection)argumentValue).Resolve(name, definition, argumentName, ResolveValueIfNecessary);
}
else if (argumentValue is TypedStringValue)
{
TypedStringValue tsv = (TypedStringValue)argumentValue;
try
{
Type resolvedTargetType = ResolveTargetType(tsv);
if (resolvedTargetType != null)
{
resolvedValue = TypeConversionUtils.ConvertValueIfNecessary(tsv.TargetType, tsv.Value, null);
}
else
{
resolvedValue = tsv.Value;
}
}
catch (Exception ex)
{
throw new ObjectCreationException(definition.ResourceDescription, name,
"Error converted typed String value for " + argumentName, ex);
}
}
else
{
// no need to resolve value...
resolvedValue = argumentValue;
}
return(resolvedValue);
}
private AbstractObjectDefinition ParseAttributeSource(XmlElement element, ParserContext parserContext)
{
XmlNodeList methods = element.SelectNodes("*[local-name()='method' and namespace-uri()='" + element.NamespaceURI + "']");
ManagedDictionary transactionAttributeMap = new ManagedDictionary();
foreach (XmlElement methodElement in methods)
{
string name = GetAttributeValue(methodElement, "name");
TypedStringValue nameHolder = new TypedStringValue(name);
RuleBasedTransactionAttribute attribute = new RuleBasedTransactionAttribute();
string propagation = GetAttributeValue(methodElement, PROPAGATION);
string isolation = GetAttributeValue(methodElement, ISOLATION);
string timeout = GetAttributeValue(methodElement, TIMEOUT);
string readOnly = GetAttributeValue(methodElement, READ_ONLY);
if (StringUtils.HasText(propagation))
{
attribute.PropagationBehavior = (TransactionPropagation)Enum.Parse(typeof(TransactionPropagation), propagation, true);
}
if (StringUtils.HasText(isolation))
{
attribute.TransactionIsolationLevel =
(IsolationLevel)Enum.Parse(typeof(IsolationLevel), isolation, true);
}
if (StringUtils.HasText(timeout))
{
try
{
attribute.TransactionTimeout = Int32.Parse(timeout);
}
catch (FormatException ex)
{
parserContext.ReaderContext.ReportException(methodElement, "tx advice", "timeout must be an integer value: [" + timeout + "]", ex);
}
}
if (StringUtils.HasText(readOnly))
{
attribute.ReadOnly = Boolean.Parse(GetAttributeValue(methodElement, READ_ONLY));
}
var rollbackRules = new List <RollbackRuleAttribute>();
if (methodElement.HasAttribute(ROLLBACK_FOR))
{
string rollbackForValue = GetAttributeValue(methodElement, ROLLBACK_FOR);
AddRollbackRuleAttributesTo(rollbackRules, rollbackForValue);
}
if (methodElement.HasAttribute(NO_ROLLBACK_FOR))
{
string noRollbackForValue = GetAttributeValue(methodElement, NO_ROLLBACK_FOR);
AddNoRollbackRuleAttributesTo(rollbackRules, noRollbackForValue);
}
attribute.RollbackRules = rollbackRules;
transactionAttributeMap[nameHolder] = attribute;
}
ObjectDefinitionBuilder builder = parserContext
.ParserHelper
.CreateRootObjectDefinitionBuilder(typeof(NameMatchTransactionAttributeSource));
builder.AddPropertyValue(NAME_MAP, transactionAttributeMap);
return(builder.ObjectDefinition);
}
private object parsePropertySubElement(XmlElement ele, IObjectDefinition bd, string defaultValueType)
{
if (!isDefaultNamespace(ele))
{
return(this.parseNestedCustomElement(ele, bd));
}
else if (this.NodeNameEquals(ele, OBJECT_ELEMENT))
{
ObjectDefinitionHolder nestedBd = this.parserContext.ParserHelper.ParseObjectDefinitionElement(ele, bd);
// if (nestedBd != null)
// {
// nestedBd = decorateObjectDefinitionIfRequired(ele, nestedBd, bd);
// }
return(nestedBd);
}
else if (this.NodeNameEquals(ele, REF_ELEMENT))
{
// A generic reference to any name of any object.
string refName = ele.GetAttribute(OBJECT_REF_ATTRIBUTE);
bool toParent = false;
if (!StringUtils.HasLength(refName))
{
// A reference to the id of another object in the same XML file.
refName = ele.GetAttribute(LOCAL_REF_ATTRIBUTE);
if (!StringUtils.HasLength(refName))
{
// A reference to the id of another object in a parent context.
refName = ele.GetAttribute(PARENT_REF_ATTRIBUTE);
toParent = true;
if (!StringUtils.HasLength(refName))
{
this.Error("'object', 'local' or 'parent' is required for <ref> element", ele);
return(null);
}
}
}
if (!StringUtils.HasText(refName))
{
this.Error("<ref> element contains empty target attribute", ele);
return(null);
}
var reference = new RuntimeObjectReference(refName, toParent);
return(reference);
}
// else if (NodeNameEquals(ele, IDREF_ELEMENT)) {
// return parseIdRefElement(ele);
// }
else if (this.NodeNameEquals(ele, VALUE_ELEMENT))
{
return(this.parseValueElement(ele, defaultValueType));
}
else if (this.NodeNameEquals(ele, NULL_ELEMENT))
{
// It's a distinguished null value. Let's wrap it in a TypedStringValue
// object in order to preserve the source location.
var nullHolder = new TypedStringValue(null);
return(nullHolder);
}
else if (this.NodeNameEquals(ele, ARRAY_ELEMENT))
{
return(this.parseArrayElement(ele, bd));
}
else if (this.NodeNameEquals(ele, LIST_ELEMENT))
{
return(this.parseListElement(ele, bd));
}
else if (this.NodeNameEquals(ele, SET_ELEMENT))
{
return(this.parseSetElement(ele, bd));
}
else if (this.NodeNameEquals(ele, MAP_ELEMENT))
{
return(this.ParseMapElement(ele, bd));
}
// else if (NodeNameEquals(ele, PROPS_ELEMENT))
// {
// return parsePropsElement(ele);
// }
else
{
this.Error("Unknown property sub-element: [" + ele.Name + "]", ele);
return(null);
}
}
/// <summary>The build typed string value for map.</summary>
/// <param name="value">The value.</param>
/// <param name="defaultTypeName">The default type name.</param>
/// <returns>The System.Object.</returns>
protected object buildTypedStringValueForMap(string value, string defaultTypeName)
{
TypedStringValue typedValue = this.buildTypedStringValue(value, defaultTypeName);
return(typedValue);
}
