private ObjectDefinitionHolder ParseTestObjectDefinition(XmlElement rootElement, ParserContext parserContext)
{
MutablePropertyValues properties = new MutablePropertyValues();
XmlNodeList childNodes = rootElement.ChildNodes;
//Get all properties (from non whitespace nodes)
foreach (XmlNode childNode in childNodes)
{
if (XmlNodeType.Whitespace != childNode.NodeType)
{
properties.Add(new PropertyValue(childNode.LocalName, childNode.InnerText));
}
}
IConfigurableObjectDefinition od = new RootObjectDefinition(typeof (TestObject), null, properties);
od.IsSingleton = false;
//HardCoded for now.
string id = "testObject";
//id = ObjectDefinitionReaderUtils.GenerateObjectName(od, reader.ObjectReader.Registry);
return new ObjectDefinitionHolder(od, id);
}
public void Instantiation () {
MutablePropertyValues root = new MutablePropertyValues ();
root.Add (new PropertyValue ("Name", "Fiona Apple"));
root.Add (new PropertyValue ("Age", 24));
MutablePropertyValues props = new MutablePropertyValues (root);
Assert.AreEqual (2, props.PropertyValues.Count);
}
public void AddAllInNullMap()
{
MutablePropertyValues props = new MutablePropertyValues ();
props.Add (new PropertyValue ("Name", "Fiona Apple"));
props.AddAll ((IDictionary) null);
Assert.AreEqual (1, props.PropertyValues.Length);
}
public void InstantiationWithNulls ()
{
MutablePropertyValues props = new MutablePropertyValues ((IDictionary<string, object>) null);
Assert.AreEqual (0, props.PropertyValues.Count);
MutablePropertyValues props2 = new MutablePropertyValues ((IPropertyValues) null);
Assert.AreEqual (0, props2.PropertyValues.Count);
}
public void ChangesSince()
{
IDictionary <string, object> map = new Dictionary <string, object>();
PropertyValue propName = new PropertyValue("Name", "Fiona Apple");
map.Add(propName.Name, propName.Value);
map.Add("Age", 24);
MutablePropertyValues props = new MutablePropertyValues(map);
MutablePropertyValues newProps = new MutablePropertyValues(map);
// change the name... this is the change we'll be looking for
newProps.SetPropertyValueAt(new PropertyValue(propName.Name, "Naomi Woolf"), 0);
IPropertyValues changes = newProps.ChangesSince(props);
Assert.AreEqual(1, changes.PropertyValues.Count);
// the name was changed, so its the name property that should be in the changed list
Assert.IsTrue(changes.Contains("name"));
newProps.Add(new PropertyValue("Commentator", "Naomi Woolf"));
changes = newProps.ChangesSince(props);
Assert.AreEqual(2, changes.PropertyValues.Count);
// the Commentator was added, so its the Commentator property that should be in the changed list
Assert.IsTrue(changes.Contains("commentator"));
// the name was changed, so its the name property that should be in the changed list
Assert.IsTrue(changes.Contains("name"));
}
/// <summary>
/// Return the difference (changes, additions, but not removals) of
/// property values between the supplied argument and the values
/// contained in the collection.
/// </summary>
/// <param name="old">Another property values collection.</param>
/// <returns>
/// The collection of property values that are different than the supplied one.
/// </returns>
public IPropertyValues ChangesSince(IPropertyValues old)
{
MutablePropertyValues changes = new MutablePropertyValues();
if (old == this)
{
return(changes);
}
// for each property value in this (the newer set)
foreach (PropertyValue newProperty in propertyValuesList)
{
PropertyValue oldProperty = old.GetPropertyValue(newProperty.Name);
if (oldProperty == null)
{
// if there wasn't an old one, add it
changes.Add(newProperty);
}
else if (!oldProperty.Equals(newProperty))
{
// it's changed
changes.Add(newProperty);
}
}
return(changes);
}
/// <summary>
/// Create the job instance, populating it with property values taken
/// from the scheduler context, job data map and trigger data map.
/// </summary>
protected override object CreateJobInstance(TriggerFiredBundle bundle)
{
ObjectWrapper ow = new ObjectWrapper(bundle.JobDetail.JobType);
if (IsEligibleForPropertyPopulation(ow.WrappedInstance))
{
MutablePropertyValues pvs = new MutablePropertyValues();
if (schedulerContext != null)
{
pvs.AddAll(schedulerContext);
}
pvs.AddAll(bundle.JobDetail.JobDataMap);
pvs.AddAll(bundle.Trigger.JobDataMap);
if (ignoredUnknownProperties != null)
{
for (int i = 0; i < ignoredUnknownProperties.Length; i++)
{
string propName = ignoredUnknownProperties[i];
if (pvs.Contains(propName))
{
pvs.Remove(propName);
}
}
ow.SetPropertyValues(pvs);
}
else
{
ow.SetPropertyValues(pvs, true);
}
}
return ow.WrappedInstance;
}
public void AddAllInNullList()
{
MutablePropertyValues props = new MutablePropertyValues ();
props.Add (new PropertyValue ("Name", "Fiona Apple"));
props.Add (new PropertyValue ("Age", 24));
props.AddAll ((IList) null);
Assert.AreEqual (2, props.PropertyValues.Length);
}
public void AddAllInList()
{
MutablePropertyValues props = new MutablePropertyValues ();
props.AddAll (new PropertyValue [] {
new PropertyValue ("Name", "Fiona Apple"),
new PropertyValue ("Age", 24)});
Assert.AreEqual (2, props.PropertyValues.Length);
}
public void AddAllInNullMap()
{
MutablePropertyValues props = new MutablePropertyValues();
props.Add(new PropertyValue("Name", "Fiona Apple"));
props.AddAll((IDictionary)null);
Assert.AreEqual(1, props.PropertyValues.Length);
}
public void AddAllInNullMap()
{
MutablePropertyValues props = new MutablePropertyValues();
props.Add(new PropertyValue("Name", "Fiona Apple"));
props.AddAll((IDictionary <string, object>)null);
Assert.AreEqual(1, props.PropertyValues.Count);
}
public void InstantiationWithNulls()
{
MutablePropertyValues props = new MutablePropertyValues((IDictionary <string, object>)null);
Assert.AreEqual(0, props.PropertyValues.Count);
MutablePropertyValues props2 = new MutablePropertyValues((IPropertyValues)null);
Assert.AreEqual(0, props2.PropertyValues.Count);
}
public void AddAllInMap()
{
MutablePropertyValues props = new MutablePropertyValues ();
IDictionary map = new Hashtable ();
map.Add ("Name", "Fiona Apple");
map.Add ("Age", 24);
props.AddAll (map);
Assert.AreEqual (2, props.PropertyValues.Length);
}
public void Contains()
{
MutablePropertyValues props = new MutablePropertyValues();
props.Add(new PropertyValue("Name", "Fiona Apple"));
props.Add(new PropertyValue("Age", 24));
// must be case insensitive to be CLS compliant...
Assert.IsTrue(props.Contains("nAmE"));
}
public void AddAllInNullList()
{
MutablePropertyValues props = new MutablePropertyValues();
props.Add(new PropertyValue("Name", "Fiona Apple"));
props.Add(new PropertyValue("Age", 24));
props.AddAll((IList <PropertyValue>)null);
Assert.AreEqual(2, props.PropertyValues.Count);
}
public void InstantiationWithNulls()
{
MutablePropertyValues props = new MutablePropertyValues((IDictionary)null);
Assert.AreEqual(0, props.PropertyValues.Length);
MutablePropertyValues props2 = new MutablePropertyValues((IPropertyValues)null);
Assert.AreEqual(0, props2.PropertyValues.Length);
}
public void AddAllInMap()
{
MutablePropertyValues props = new MutablePropertyValues();
IDictionary <string, object> map = new Dictionary <string, object>();
map.Add("Name", "Fiona Apple");
map.Add("Age", 24);
props.AddAll(map);
Assert.AreEqual(2, props.PropertyValues.Count);
}
public void RemoveByName()
{
MutablePropertyValues props = new MutablePropertyValues();
props.Add(new PropertyValue("Name", "Fiona Apple"));
props.Add(new PropertyValue("Age", 24));
Assert.AreEqual(2, props.PropertyValues.Count);
props.Remove("name");
Assert.AreEqual(1, props.PropertyValues.Count);
}
public void AddAllInMap()
{
MutablePropertyValues props = new MutablePropertyValues();
IDictionary map = new Hashtable();
map.Add("Name", "Fiona Apple");
map.Add("Age", 24);
props.AddAll(map);
Assert.AreEqual(2, props.PropertyValues.Length);
}
public void Instantiation()
{
MutablePropertyValues root = new MutablePropertyValues();
root.Add(new PropertyValue("Name", "Fiona Apple"));
root.Add(new PropertyValue("Age", 24));
MutablePropertyValues props = new MutablePropertyValues(root);
Assert.AreEqual(2, props.PropertyValues.Count);
}
public void AddAllInList()
{
MutablePropertyValues props = new MutablePropertyValues();
props.AddAll(new PropertyValue [] {
new PropertyValue("Name", "Fiona Apple"),
new PropertyValue("Age", 24)
});
Assert.AreEqual(2, props.PropertyValues.Count);
}
private MutablePropertyValues getMutablePropertyValues(TypeRegistration registrationEntry)
{
MutablePropertyValues properties = new MutablePropertyValues();
foreach (InjectedProperty property in registrationEntry.InjectedProperties)
{
properties.Add(new PropertyValue(property.PropertyName,getInjectionParameterValue(property.PropertyValue)));
}
return properties;
}
public void RemoveByPropertyValue()
{
MutablePropertyValues props = new MutablePropertyValues();
PropertyValue propName = new PropertyValue("Name", "Fiona Apple");
props.Add(propName);
props.Add(new PropertyValue("Age", 24));
Assert.AreEqual(2, props.PropertyValues.Length);
props.Remove(propName);
Assert.AreEqual(1, props.PropertyValues.Length);
}
public void ChangesSinceWithSelf()
{
IDictionary <string, object> map = new Dictionary <string, object>();
map.Add("Name", "Fiona Apple");
map.Add("Age", 24);
MutablePropertyValues props = new MutablePropertyValues(map);
props.Remove("name");
// get all of the changes between self and self again (there should be none);
IPropertyValues changes = props.ChangesSince(props);
Assert.AreEqual(0, changes.PropertyValues.Count);
}
/// <summary>
/// This implementation applies the passed-in job data map as object property
/// values, and delegates to <code>ExecuteInternal</code> afterwards.
/// </summary>
/// <seealso cref="ExecuteInternal" />
public void Execute(IJobExecutionContext context)
{
try
{
ObjectWrapper bw = new ObjectWrapper(this);
MutablePropertyValues pvs = new MutablePropertyValues();
pvs.AddAll(context.Scheduler.Context);
pvs.AddAll(context.MergedJobDataMap);
bw.SetPropertyValues(pvs, true);
}
catch (SchedulerException ex)
{
throw new JobExecutionException(ex);
}
ExecuteInternal(context);
}
public override IPropertyValues PostProcessPropertyValues(IPropertyValues propertyValues, PropertyInfo[] propertyInfos, object objectInstance, string objectName)
{
MutablePropertyValues mpv = new MutablePropertyValues(propertyValues);
IConfigurableObjectDefinition objectDefinition = (IConfigurableObjectDefinition)_objectFactory.GetObjectDefinition(objectName);
DependencyCheckingMode checkMode = objectDefinition.DependencyCheck;
PropertyInfo[] unresolvedProperties = AutowireUtils.GetUnsatisfiedDependencies(propertyInfos, propertyValues, checkMode);
foreach(PropertyInfo propertyInfo in unresolvedProperties)
{
object value = ResolveDependency(objectName, objectDefinition, new ObjectWrapper(objectInstance), propertyInfo);
if (value != null)
{
mpv.Add(propertyInfo.Name, value);
}
}
return base.PostProcessPropertyValues(mpv, propertyInfos, objectInstance, objectName);
}
public void ChangesSince()
{
IDictionary map = new Hashtable ();
PropertyValue propName = new PropertyValue ("Name", "Fiona Apple");
map.Add (propName.Name, propName.Value);
map.Add ("Age", 24);
MutablePropertyValues props = new MutablePropertyValues (map);
MutablePropertyValues newProps = new MutablePropertyValues (map);
// change the name... this is the change we'll be looking for
newProps.SetPropertyValueAt (new PropertyValue (propName.Name, "Naomi Woolf"), 0);
IPropertyValues changes = newProps.ChangesSince (props);
Assert.AreEqual (1, changes.PropertyValues.Length);
// the name was changed, so its the name property that should be in the changed list
Assert.IsTrue (changes.Contains ("name"));
newProps.Add (new PropertyValue ("Commentator", "Naomi Woolf"));
changes = newProps.ChangesSince (props);
Assert.AreEqual (2, changes.PropertyValues.Length);
// the Commentator was added, so its the Commentator property that should be in the changed list
Assert.IsTrue (changes.Contains ("commentator"));
// the name was changed, so its the name property that should be in the changed list
Assert.IsTrue (changes.Contains ("name"));
}
/// <summary>
/// Configures the NVelocity resource loader definitions from the xml definition
/// </summary>
/// <param name="element">the root resource loader element</param>
/// <param name="objectDefinitionProperties">the MutablePropertyValues used to configure this object</param>
/// <param name="properties">the properties used to initialize the velocity engine</param>
private void ParseResourceLoader(XmlElement element, MutablePropertyValues objectDefinitionProperties, IDictionary<string, object> properties) {
string caching = GetAttributeValue(element, TemplateDefinitionConstants.AttributeTemplateCaching);
string defaultCacheSize = GetAttributeValue(element, TemplateDefinitionConstants.AttributeDefaultCacheSize);
string modificationCheckInterval = GetAttributeValue(element, TemplateDefinitionConstants.AttributeModificationCheckInterval);
if (!string.IsNullOrEmpty(defaultCacheSize)) {
properties.Add(RuntimeConstants.RESOURCE_MANAGER_DEFAULTCACHE_SIZE, defaultCacheSize);
}
XmlNodeList loaderElements = element.ChildNodes;
switch (loaderElements[0].LocalName) {
case VelocityConstants.File:
AppendFileLoaderProperties(loaderElements, properties);
AppendResourceLoaderGlobalProperties(properties, VelocityConstants.File, caching,
modificationCheckInterval);
break;
case VelocityConstants.Assembly:
AppendAssemblyLoaderProperties(loaderElements, properties);
AppendResourceLoaderGlobalProperties(properties, VelocityConstants.Assembly, caching, null);
break;
case TemplateDefinitionConstants.Spring:
AppendResourceLoaderPaths(loaderElements, objectDefinitionProperties);
AppendResourceLoaderGlobalProperties(properties, TemplateDefinitionConstants.Spring, caching, null);
break;
case TemplateDefinitionConstants.Custom:
XmlElement firstElement = (XmlElement)loaderElements.Item(0);
AppendCustomLoaderProperties(firstElement, properties);
AppendResourceLoaderGlobalProperties(properties, firstElement.LocalName, caching, modificationCheckInterval);
break;
default:
throw new ArgumentException(string.Format("undefined element for resource loadre type: {0}", element.LocalName));
}
}
/// <summary>
/// Parses child element definitions for the NVelocity engine. Typically resource loaders and locally defined properties are parsed here
/// </summary>
/// <param name="childElements">the XmlNodeList representing the child configuration of the root NVelocity engine element</param>
/// <param name="parserContext">the parser context</param>
/// <param name="objectDefinitionProperties">the MutablePropertyValues used to configure this object</param>
private void ParseChildDefinitions(XmlNodeList childElements, ParserContext parserContext, MutablePropertyValues objectDefinitionProperties) {
IDictionary<string, object> properties = new Dictionary<string, object>();
foreach (XmlElement element in childElements) {
switch (element.LocalName) {
case TemplateDefinitionConstants.ElementResourceLoader:
ParseResourceLoader(element, objectDefinitionProperties, properties);
break;
case TemplateDefinitionConstants.ElementNVelocityProperties:
ParseNVelocityProperties(element, parserContext, properties);
break;
}
}
if (properties.Count > 0) {
objectDefinitionProperties.Add(TemplateDefinitionConstants.PropertyVelocityProperties, properties);
}
}
/// <summary>
/// Creates an error message action based on the specified message element.
/// </summary>
/// <param name="message">The message element.</param>
/// <param name="parserContext">The parser helper.</param>
/// <returns>The error message action definition.</returns>
private static IObjectDefinition ParseErrorMessageAction(XmlElement message, ParserContext parserContext)
{
string messageId = GetAttributeValue(message, MessageConstants.IdAttribute);
string[] providers = GetAttributeValue(message, MessageConstants.ProvidersAttribute).Split(',');
ArrayList parameters = new ArrayList();
foreach (XmlElement param in message.ChildNodes)
{
IExpression paramExpression = Expression.Parse(GetAttributeValue(param, MessageConstants.ParameterValueAttribute));
parameters.Add(paramExpression);
}
string typeName = "Spring.Validation.Actions.ErrorMessageAction, Spring.Core";
ConstructorArgumentValues ctorArgs = new ConstructorArgumentValues();
ctorArgs.AddGenericArgumentValue(messageId);
ctorArgs.AddGenericArgumentValue(providers);
string when = GetAttributeValue(message, ValidatorDefinitionConstants.WhenAttribute);
MutablePropertyValues properties = new MutablePropertyValues();
if (StringUtils.HasText(when))
{
properties.Add("When", when);
}
if (parameters.Count > 0)
{
properties.Add("Parameters", parameters.ToArray(typeof(IExpression)));
}
IConfigurableObjectDefinition action =
parserContext.ReaderContext.ObjectDefinitionFactory.CreateObjectDefinition(typeName, null, parserContext.ReaderContext.Reader.Domain);
action.ConstructorArgumentValues = ctorArgs;
action.PropertyValues = properties;
return action;
}
public void ChangesSinceWithSelf ()
{
IDictionary<string, object> map = new Dictionary<string, object>();
map.Add("Name", "Fiona Apple");
map.Add ("Age", 24);
MutablePropertyValues props = new MutablePropertyValues (map);
props.Remove ("name");
// get all of the changes between self and self again (there should be none);
IPropertyValues changes = props.ChangesSince (props);
Assert.AreEqual (0, changes.PropertyValues.Count);
}
public void DoTestMessageAccess(bool hasParentContext, bool useCodeAsDefaultMessage)
{
StaticApplicationContext ac = new StaticApplicationContext();
if (hasParentContext)
{
StaticApplicationContext parent = new StaticApplicationContext();
parent.Refresh();
ac.ParentContext = parent;
}
MutablePropertyValues pvs = new MutablePropertyValues();
pvs.Add("resourceManagers", resourceManagerList);
if (useCodeAsDefaultMessage)
{
pvs.Add("UseCodeAsDefaultMessage", true);
}
ac.RegisterSingleton("messageSource", typeof(ResourceSetMessageSource), pvs);
ac.Refresh();
// Localizaiton fallbacks
GetMessageLocalizationFallbacks(ac);
// MessageSourceAccessor functionality
MessageSourceAccessor accessor = new MessageSourceAccessor(ac);
Assert.AreEqual("message3", accessor.GetMessage("code3", CultureInfo.CurrentUICulture, (object[])null));
// IMessageSourceResolveable
Assert.AreEqual("message3", ac.GetMessage("code3", CultureInfo.CurrentUICulture, (object[])null));
IMessageSourceResolvable resolvable = new DefaultMessageSourceResolvable("code3");
Assert.AreEqual("message3", ac.GetMessage(resolvable, CultureInfo.CurrentUICulture));
resolvable = new DefaultMessageSourceResolvable(new string[] { "code4", "code3" });
Assert.AreEqual("message3", ac.GetMessage(resolvable, CultureInfo.CurrentUICulture));
Assert.AreEqual("message3", ac.GetMessage("code3", CultureInfo.CurrentUICulture, (object[])null));
resolvable = new DefaultMessageSourceResolvable(new string[] { "code4", "code3" });
Assert.AreEqual("message3", ac.GetMessage(resolvable, CultureInfo.CurrentUICulture));
object[] arguments = new object[] { "Hello", new DefaultMessageSourceResolvable(new string[] { "code1" }) };
Assert.AreEqual("Hello, message1", ac.GetMessage("hello", CultureInfo.CurrentUICulture, arguments));
// test default message without and with args
Assert.AreEqual("default", ac.GetMessage(null, "default", CultureInfo.CurrentUICulture, null));
Assert.AreEqual("default", ac.GetMessage(null, "default", CultureInfo.CurrentUICulture, arguments));
/* not supported
Assert.AreEqual("{0}, default", ac.GetMessage(null, "{0}, default", CultureInfo.CurrentUICulture, null));
*/
Assert.AreEqual("Hello, default", ac.GetMessage(null, "{0}, default", CultureInfo.CurrentUICulture, arguments));
// test resolvable with default message, without and with args
resolvable = new DefaultMessageSourceResolvable(null, null, "default");
Assert.AreEqual("default", ac.GetMessage(resolvable, CultureInfo.CurrentUICulture));
resolvable = new DefaultMessageSourceResolvable(null, arguments, "default");
Assert.AreEqual("default", ac.GetMessage(resolvable, CultureInfo.CurrentUICulture));
/* not supported
resolvable = new DefaultMessageSourceResolvable(null, null, "{0}, default");
Assert.AreEqual("{0}, default", ac.GetMessage(resolvable, CultureInfo.CurrentUICulture));
*/
resolvable = new DefaultMessageSourceResolvable(null, arguments, "{0}, default");
Assert.AreEqual("Hello, default", ac.GetMessage(resolvable, CultureInfo.CurrentUICulture));
// test message args
Assert.AreEqual("Arg1, Arg2", ac.GetMessage("hello", CultureInfo.CurrentUICulture, new object[] { "Arg1", "Arg2" }));
/* not supported
Assert.AreEqual("{0}, {1}", ac.GetMessage("hello", CultureInfo.CurrentUICulture, null));
*/
/* not supported
Assert.AreEqual("Hello\nWorld", ac.GetMessage("escaped"));
}
else
{
Assert.AreEqual("Hello\\nWorld", ac.GetMessage("escaped"));
}
*/
try
{
Assert.AreEqual("MyNonExistantMessage", ac.GetMessage("MyNonExistantMessage"));
if (!useCodeAsDefaultMessage)
{
Assert.Fail("Should have thrown NoSuchMessagException");
}
}
catch (NoSuchMessageException e)
{
if (useCodeAsDefaultMessage)
{
Assert.Fail("Should have returned code as default message.");
e.ToString();
}
}
}
public void RemoveByPropertyValue ()
{
MutablePropertyValues props = new MutablePropertyValues ();
PropertyValue propName = new PropertyValue ("Name", "Fiona Apple");
props.Add (propName);
props.Add (new PropertyValue ("Age", 24));
Assert.AreEqual (2, props.PropertyValues.Count);
props.Remove (propName);
Assert.AreEqual (1, props.PropertyValues.Count);
}
private IObjectDefinition ParseExceptionAction(XmlElement element, ParserContext parserContext)
{
string typeName = "Spring.Validation.Actions.ExceptionAction, Spring.Core";
string throwExpression = GetAttributeValue(element, ValidatorDefinitionConstants.ThrowAttribute);
ConstructorArgumentValues ctorArgs = new ConstructorArgumentValues();
ctorArgs.AddGenericArgumentValue(throwExpression);
string when = GetAttributeValue(element, ValidatorDefinitionConstants.WhenAttribute);
MutablePropertyValues properties = new MutablePropertyValues();
if (StringUtils.HasText(when))
{
properties.Add("When", when);
}
IConfigurableObjectDefinition action =
parserContext.ReaderContext.ObjectDefinitionFactory.CreateObjectDefinition(typeName, null, parserContext.ReaderContext.Reader.Domain);
action.ConstructorArgumentValues = ctorArgs;
action.PropertyValues = properties;
return action;
}
/// <summary>
/// Parses the CaoExporter definition.
/// </summary>
/// <param name="element">The element to parse.</param>
/// <param name="name">The name of the object definition.</param>
/// <param name="parserContext">The parser context.</param>
/// <returns>CaoExporter object definition.</returns>
private IConfigurableObjectDefinition ParseCaoExporter(
XmlElement element, string name, ParserContext parserContext)
{
string typeName = GetTypeName(element);
string targetName = element.GetAttribute(CaoExporterConstants.TargetNameAttribute);
string infinite = element.GetAttribute(CaoExporterConstants.InfiniteAttribute);
MutablePropertyValues properties = new MutablePropertyValues();
if (StringUtils.HasText(targetName))
{
properties.Add("TargetName", targetName);
}
if (StringUtils.HasText(infinite))
{
properties.Add("Infinite", infinite);
}
foreach (XmlElement child in element.ChildNodes)
{
switch (child.LocalName)
{
case LifeTimeConstants.LifeTimeElement:
ParseLifeTime(properties, child, parserContext);
break;
case InterfacesConstants.InterfacesElement:
properties.Add("Interfaces", base.ParseListElement(child, name, parserContext));
break;
}
}
IConfigurableObjectDefinition cod = parserContext.ReaderContext.ObjectDefinitionFactory.CreateObjectDefinition(
typeName, null, parserContext.ReaderContext.Reader.Domain);
cod.PropertyValues = properties;
return cod;
}
/// <summary>
/// Parses the LifeTime definition.
/// </summary>
private void ParseLifeTime(MutablePropertyValues properties, XmlElement child, ParserContext parserContext)
{
string initialLeaseTime = child.GetAttribute(LifeTimeConstants.InitialLeaseTimeAttribute);
string renewOnCallTime = child.GetAttribute(LifeTimeConstants.RenewOnCallTimeAttribute);
string sponsorshipTimeout = child.GetAttribute(LifeTimeConstants.SponsorshipTimeoutAttribute);
if (StringUtils.HasText(initialLeaseTime))
{
properties.Add("InitialLeaseTime", initialLeaseTime);
}
if (StringUtils.HasText(renewOnCallTime))
{
properties.Add("RenewOnCallTime", renewOnCallTime);
}
if (StringUtils.HasText(sponsorshipTimeout))
{
properties.Add("SponsorshipTimeout", sponsorshipTimeout);
}
}
/// <summary>
/// Parses the CaoFactoryObject definition.
/// </summary>
/// <param name="element">The element to parse.</param>
/// <param name="name">The name of the object definition.</param>
/// <param name="parserContext">The parser context.</param>
/// <returns>CaoFactoryObject object definition.</returns>
private IConfigurableObjectDefinition ParseCaoFactoryObject(
XmlElement element, string name, ParserContext parserContext)
{
string typeName = GetTypeName(element);
string remoteTargetName = element.GetAttribute(CaoFactoryObjectConstants.RemoteTargetNameAttribute);
string serviceUrl = element.GetAttribute(CaoFactoryObjectConstants.ServiceUrlAttribute);
MutablePropertyValues properties = new MutablePropertyValues();
if (StringUtils.HasText(remoteTargetName))
{
properties.Add("RemoteTargetName", remoteTargetName);
}
if (StringUtils.HasText(serviceUrl))
{
properties.Add("ServiceUrl", serviceUrl);
}
foreach (XmlElement child in element.ChildNodes)
{
switch (child.LocalName)
{
case CaoFactoryObjectConstants.ConstructorArgumentsElement:
properties.Add("ConstructorArguments", base.ParseListElement(child, name, parserContext));
break;
}
}
IConfigurableObjectDefinition cod = parserContext.ReaderContext.ObjectDefinitionFactory.CreateObjectDefinition(
typeName, null, parserContext.ReaderContext.Reader.Domain);
cod.PropertyValues = properties;
return cod;
}
/// <summary>
/// Parses the SaoFactoryObject definition.
/// </summary>
/// <param name="element">The element to parse.</param>
/// <param name="name">The name of the object definition.</param>
/// <param name="parserContext">The parser context.</param>
/// <returns>SaoFactoryObject object definition.</returns>
private IConfigurableObjectDefinition ParseSaoFactoryObject(
XmlElement element, string name, ParserContext parserContext)
{
string typeName = GetTypeName(element);
string serviceInterface = element.GetAttribute(SaoFactoryObjectConstants.ServiceInterfaceAttribute);
string serviceUrl = element.GetAttribute(SaoFactoryObjectConstants.ServiceUrlAttribute);
MutablePropertyValues properties = new MutablePropertyValues();
if (StringUtils.HasText(serviceInterface))
{
properties.Add("ServiceInterface", serviceInterface);
}
if (StringUtils.HasText(serviceUrl))
{
properties.Add("ServiceUrl", serviceUrl);
}
IConfigurableObjectDefinition cod = parserContext.ReaderContext.ObjectDefinitionFactory.CreateObjectDefinition(
typeName, null, parserContext.ReaderContext.Reader.Domain);
cod.PropertyValues = properties;
return cod;
}
/// <summary>
/// Parses the RemotingConfigurer definition.
/// </summary>
/// <param name="element">The element to parse.</param>
/// <param name="name">The name of the object definition.</param>
/// <param name="parserContext">The parser context.</param>
/// <returns>RemotingConfigurer object definition.</returns>
private IConfigurableObjectDefinition ParseRemotingConfigurer(
XmlElement element, string name, ParserContext parserContext)
{
string typeName = GetTypeName(element);
string filename = element.GetAttribute(RemotingConfigurerConstants.FilenameAttribute);
string useConfigFile = element.GetAttribute(RemotingConfigurerConstants.UseConfigFileAttribute);
string ensureSecurity = element.GetAttribute(RemotingConfigurerConstants.EnsureSecurityAttribute);
MutablePropertyValues properties = new MutablePropertyValues();
if (StringUtils.HasText(filename))
{
properties.Add("Filename", filename);
}
if (StringUtils.HasText(useConfigFile))
{
properties.Add("UseConfigFile", useConfigFile);
}
if (StringUtils.HasText(ensureSecurity))
{
properties.Add("EnsureSecurity", ensureSecurity);
}
IConfigurableObjectDefinition cod = parserContext.ReaderContext.ObjectDefinitionFactory.CreateObjectDefinition(
typeName, null, parserContext.ReaderContext.Reader.Domain);
cod.PropertyValues = properties;
return cod;
}
/// <summary>
/// Creates a spring resource loader by setting the ResourceLoaderPaths of the
/// engine factory (the resource loader itself will be created internally either as
/// spring or as file resource loader based on the value of prefer-file-system-access
/// attribute).
/// </summary>
/// <param name="elements">list of resource loader path elements</param>
/// <param name="objectDefinitionProperties">the MutablePropertyValues to set the property for the engine factory</param>
private void AppendResourceLoaderPaths(XmlNodeList elements, MutablePropertyValues objectDefinitionProperties) {
IList<string> paths = new List<string>();
foreach (XmlElement element in elements) {
string path = GetAttributeValue(element, TemplateDefinitionConstants.AttributeUri);
paths.Add(path);
}
objectDefinitionProperties.Add(TemplateDefinitionConstants.PropertyResourceLoaderPaths, paths);
}
public void AddAllInMap ()
{
MutablePropertyValues props = new MutablePropertyValues ();
IDictionary<string, object> map = new Dictionary<string, object>();
map.Add("Name", "Fiona Apple");
map.Add ("Age", 24);
props.AddAll (map);
Assert.AreEqual (2, props.PropertyValues.Count);
}
/// <summary>
/// Parses the object definition for the engine object, configures a single NVelocity template engine based
/// on the element definitions.
/// </summary>
/// <param name="element">the root element defining the velocity engine</param>
/// <param name="parserContext">the parser context</param>
private IConfigurableObjectDefinition ParseNVelocityEngine(XmlElement element, ParserContext parserContext) {
string typeName = GetTypeName(element);
IConfigurableObjectDefinition configurableObjectDefinition = parserContext.ReaderContext.ObjectDefinitionFactory.CreateObjectDefinition(
typeName, null, parserContext.ReaderContext.Reader.Domain);
string preferFileSystemAccess = GetAttributeValue(element, TemplateDefinitionConstants.AttributePreferFileSystemAccess);
string overrideLogging = GetAttributeValue(element, TemplateDefinitionConstants.AttributeOverrideLogging);
string configFile = GetAttributeValue(element, TemplateDefinitionConstants.AttributeConfigFile);
MutablePropertyValues objectDefinitionProperties = new MutablePropertyValues();
if (StringUtils.HasText(preferFileSystemAccess)) {
objectDefinitionProperties.Add(TemplateDefinitionConstants.PropertyPreferFileSystemAccess, preferFileSystemAccess);
}
if (StringUtils.HasText(overrideLogging)) {
objectDefinitionProperties.Add(TemplateDefinitionConstants.PropertyOverrideLogging, overrideLogging);
}
if (StringUtils.HasText(configFile)) {
objectDefinitionProperties.Add(TemplateDefinitionConstants.PropertyConfigFile, configFile);
}
XmlNodeList childElements = element.ChildNodes;
if (childElements.Count > 0) {
ParseChildDefinitions(childElements, parserContext, objectDefinitionProperties);
}
configurableObjectDefinition.PropertyValues = objectDefinitionProperties;
return configurableObjectDefinition;
}
public void AddAllInNullMap ()
{
MutablePropertyValues props = new MutablePropertyValues ();
props.Add (new PropertyValue ("Name", "Fiona Apple"));
props.AddAll ((IDictionary<string, object>) null);
Assert.AreEqual (1, props.PropertyValues.Count);
}
public void Contains ()
{
MutablePropertyValues props = new MutablePropertyValues ();
props.Add (new PropertyValue ("Name", "Fiona Apple"));
props.Add (new PropertyValue ("Age", 24));
// must be case insensitive to be CLS compliant...
Assert.IsTrue (props.Contains ("nAmE"));
}
/// <summary>
/// Creates object definition for the validator reference.
/// </summary>
/// <param name="element">The action definition element.</param>
/// <param name="parserContext">The parser helper.</param>
/// <returns>Generic validation action definition.</returns>
private IObjectDefinition ParseValidatorReference(XmlElement element, ParserContext parserContext)
{
string typeName = "Spring.Validation.ValidatorReference, Spring.Core";
string name = GetAttributeValue(element, ValidatorDefinitionConstants.ReferenceNameAttribute);
string context = GetAttributeValue(element, ValidatorDefinitionConstants.ReferenceContextAttribute);
string when = GetAttributeValue(element, ValidatorDefinitionConstants.WhenAttribute);
MutablePropertyValues properties = new MutablePropertyValues();
properties.Add("Name", name);
if (StringUtils.HasText(context))
{
properties.Add("Context", context);
}
if (StringUtils.HasText(when))
{
properties.Add("When", when);
}
IConfigurableObjectDefinition reference =
parserContext.ReaderContext.ObjectDefinitionFactory.CreateObjectDefinition(typeName, null, parserContext.ReaderContext.Reader.Domain);
reference.PropertyValues = properties;
return reference;
}