protected override void DoParse(XmlElement element, ParserContext parserContext, ObjectDefinitionBuilder builder)
{
builder.AddPropertyReference(TxNamespaceUtils.TRANSACTION_MANAGER_PROPERTY,
GetAttributeValue(element, TxNamespaceUtils.TRANSACTION_MANAGER_ATTRIBUTE));
XmlNodeList txAttributes = element.SelectNodes("*[local-name()='attributes' and namespace-uri()='" + element.NamespaceURI + "']");
if (txAttributes.Count > 1 )
{
parserContext.ReaderContext.ReportException(element, "tx advice", "Element <attributes> is allowed at most once inside element <advice>");
}
else if (txAttributes.Count == 1)
{
//using xml defined source
XmlElement attributeSourceElement = txAttributes[0] as XmlElement;
AbstractObjectDefinition attributeSourceDefinition =
ParseAttributeSource(attributeSourceElement, parserContext);
builder.AddPropertyValue(TxNamespaceUtils.TRANSACTION_ATTRIBUTE_SOURCE, attributeSourceDefinition);
}
else
{
//Assume attibutes source
ObjectDefinitionBuilder txAttributeSourceBuilder =
parserContext.ParserHelper.CreateRootObjectDefinitionBuilder(typeof (AttributesTransactionAttributeSource));
builder.AddPropertyValue(TxNamespaceUtils.TRANSACTION_ATTRIBUTE_SOURCE,
txAttributeSourceBuilder.ObjectDefinition);
}
}
public void Configure(ObjectDefinitionBuilder builder)
{
foreach (string key in _properties.Keys)
{
builder.AddPropertyValue(key, _properties[key]);
}
}
private static void ParseQueueCapacity(ObjectDefinitionBuilder builder, XmlElement queueElement)
{
string capacity = queueElement.GetAttribute("capacity");
if (StringUtils.HasText(capacity)) {
builder.AddConstructorArg(Convert.ToUInt32(capacity));
}
}
/// <summary>
/// Creates a new <see cref="ObjectDefinitionBuilder"/> used to construct a <see cref="Spring.Objects.Factory.Support.GenericObjectDefinition"/>.
/// </summary>
/// <param name="objectType">the <see cref="Type"/> of the object that the definition is being created for</param>
public static ObjectDefinitionBuilder GenericObjectDefinition(Type objectType)
{
ObjectDefinitionBuilder builder = new ObjectDefinitionBuilder();
builder.objectDefinition = new GenericObjectDefinition();
builder.objectDefinition.ObjectType = objectType;
return builder;
}
protected override void DoParse(XmlElement element, ObjectDefinitionBuilder builder)
{
base.DoParse(element, builder);
ParseSimpleProperties(element, builder);
XmlNodeList subElements = element.ChildNodes;
ManagedList locators = new ManagedList(subElements.Count);
ManagedList servers = new ManagedList(subElements.Count);
for (int i = 0; i < subElements.Count; i++) {
XmlNode subElement = subElements.Item(i);
if (subElement != null && subElement.NodeType == XmlNodeType.Element)
{
if ("locator".Equals(subElement.LocalName))
{
locators.Add(ParseLocator((XmlElement)subElement));
}
if ("server".Equals(subElement.LocalName))
{
servers.Add(ParseServer((XmlElement)subElement));
}
}
}
if (locators.Count > 0)
{
builder.AddPropertyValue("Locators", locators);
}
if (servers.Count > 0)
{
builder.AddPropertyValue("Servers", servers);
}
}
protected override void DoParse(XmlElement element, ParserContext parserContext, ObjectDefinitionBuilder builder)
{
if(!StringUtils.HasText(element.GetAttribute("id"))) {
parserContext.ReaderContext.ReportException(element, element.Name, "id is required");
}
ParseSelectorChain(builder, element, parserContext);
}
/// <summary>The do parse.</summary>
/// <param name="element">The element.</param>
/// <param name="parserContext">The parser context.</param>
/// <param name="builder">The builder.</param>
protected override void DoParse(XmlElement element, ParserContext parserContext, ObjectDefinitionBuilder builder)
{
var parser = new ObjectDefinitionParserHelper(parserContext);
var map = parser.ParseMapElement(element, builder.RawObjectDefinition);
builder.AddPropertyValue("SourceDictionary", map);
}
/// <summary>
/// Creates a new <see cref="ObjectDefinitionBuilder"/> used to construct a <see cref="Spring.Objects.Factory.Support.GenericObjectDefinition"/>.
/// </summary>
public static ObjectDefinitionBuilder GenericObjectDefinition()
{
ObjectDefinitionBuilder builder = new ObjectDefinitionBuilder();
builder.objectDefinition = new GenericObjectDefinition();
return(builder);
}
protected override void DoParse(XmlElement element, ObjectDefinitionBuilder builder)
{
base.DoParse(element, builder);
ParsingUtils.SetPropertyValue(element, builder, "name", "name");
String attr = element.GetAttribute("cache-ref");
// add cache reference (fallback to default if nothing is specified)
builder.AddPropertyReference("cache", (StringUtils.HasText(attr) ? attr : "gemfire-cache"));
}
/// <summary>
/// Creates a new <see cref="ObjectDefinitionBuilder"/> used to construct a <see cref="Spring.Objects.Factory.Support.GenericObjectDefinition"/>.
/// </summary>
/// <param name="objectTypeName">the name of the <see cref="Type"/> of the object that the definition is being created for</param>
public static ObjectDefinitionBuilder GenericObjectDefinition(string objectTypeName)
{
ObjectDefinitionBuilder builder = new ObjectDefinitionBuilder();
builder.objectDefinition = new GenericObjectDefinition();
builder.objectDefinition.ObjectTypeName = objectTypeName;
return(builder);
}
protected override void DoParse(XmlElement element, ParserContext parserContext, ObjectDefinitionBuilder builder)
{
base.DoParse(element, builder);
//TODO investigate setting of scope on client cache
//builder.AddPropertyValue("Scope", "some value");
//TODO check if .NET client has any 'data policy' settings.
ParsingUtils.SetPropertyValue(element, builder, "name", "name");
ParsingUtils.SetPropertyValue(element, builder, "pool-name", "poolName");
String cacheRef = element.GetAttribute("cache-ref");
// add cache reference (fallback to default if nothing is specified)
builder.AddPropertyReference("cache", (StringUtils.HasText(cacheRef) ? cacheRef : "gemfire-cache"));
// client region attributes
String regionAttributesRef = element.GetAttribute("attributes-ref");
if (StringUtils.HasText(regionAttributesRef))
{
ObjectDefinitionBuilder attrBuilder = ObjectDefinitionBuilder.GenericObjectDefinition(typeof(RegionAttributesFactoryObject));
builder.AddPropertyReference("attributes", regionAttributesRef);
}
ManagedList interests = new ManagedList();
XmlNodeList subElements = element.ChildNodes;
for (int i = 0; i < subElements.Count; i++)
{
XmlNode subElement = subElements.Item(i);
if (subElement.NodeType == XmlNodeType.Element)
{
string name = subElement.LocalName;
if ("cache-listener".Equals(name))
{
builder.AddPropertyValue("cacheListeners", ParseCacheListener(parserContext, (XmlElement)subElement, builder));
}
else if ("regex-interest".Equals(name))
{
interests.Add(ParseRegexInterest(parserContext, (XmlElement)subElement));
}
else if ("key-interest".Equals(name))
{
interests.Add(ParseKeyInterest(parserContext, (XmlElement)subElement));
}
else if ("all-keys-interest".Equals(name))
{
interests.Add(ParseAllKeysInterest(parserContext, (XmlElement) subElement));
}
}
}
if (subElements.Count > 0)
{
builder.AddPropertyValue("interests", interests);
}
}
protected override void DoParse(XmlElement element, ObjectDefinitionBuilder builder)
{
base.DoParse(element, builder);
ParsingUtils.SetPropertyValue(element, builder, "cache-xml-location", "CacheXml");
ParsingUtils.SetPropertyValue(element, builder, "disconnect-on-close", "DisconnectOnClose");
ParsingUtils.SetPropertyValue(element, builder, "keepalive-on-close", "KeepAliveOnClose");
ParsingUtils.SetPropertyValue(element, builder, "distributed-system-name", "DistributedSystemName");
ParsingUtils.SetPropertyReference(element, builder, "properties-ref", "Properties");
}
protected override void DoParse(XmlElement element, ObjectDefinitionBuilder builder)
{
string parentFlow = element.GetAttribute("parent");
if (!string.IsNullOrEmpty(parentFlow))
{
builder.AddPropertyReference("ParentFlow", parentFlow);
}
DoParseInternal(element,builder);
}
public void ObjectType()
{
ObjectDefinitionBuilder odb = ObjectDefinitionBuilder.RootObjectDefinition(odf, typeof(TestObject));
RootObjectDefinition rod = odb.ObjectDefinition as RootObjectDefinition;
Assert.IsNotNull(rod);
Assert.IsTrue(rod.HasObjectType);
Assert.AreEqual(typeof(TestObject), rod.ObjectType);
}
public void ObjectNameChild()
{
ObjectDefinitionBuilder odb = ObjectDefinitionBuilder.ChildObjectDefinition(odf, typeof(TestObject).FullName);
ChildObjectDefinition rod = odb.ObjectDefinition as ChildObjectDefinition;
Assert.IsNotNull(rod);
Assert.IsFalse(rod.HasObjectType);
Assert.AreEqual(typeof(TestObject).FullName, rod.ParentName);
}
/// <summary>The do parse.</summary>
/// <param name="element">The element.</param>
/// <param name="parserContext">The parser context.</param>
/// <param name="builder">The builder.</param>
protected override void DoParse(XmlElement element, ParserContext parserContext, ObjectDefinitionBuilder builder)
{
var connectionFactoryRef = element.GetAttribute(CONNECTION_FACTORY_ATTRIBUTE);
if (string.IsNullOrWhiteSpace(connectionFactoryRef))
{
parserContext.ReaderContext.ReportFatalException(element, "A '" + CONNECTION_FACTORY_ATTRIBUTE + "' attribute must be set.");
}
if (!string.IsNullOrWhiteSpace(connectionFactoryRef))
{
// Use constructor with connectionFactory parameter
builder.AddConstructorArgReference(connectionFactoryRef);
}
NamespaceUtils.SetValueIfAttributeDefined(builder, element, CHANNEL_TRANSACTED_ATTRIBUTE);
NamespaceUtils.SetValueIfAttributeDefined(builder, element, QUEUE_ATTRIBUTE);
NamespaceUtils.SetValueIfAttributeDefined(builder, element, EXCHANGE_ATTRIBUTE);
NamespaceUtils.SetValueIfAttributeDefined(builder, element, ROUTING_KEY_ATTRIBUTE);
NamespaceUtils.SetValueIfAttributeDefined(builder, element, REPLY_TIMEOUT_ATTRIBUTE);
NamespaceUtils.SetValueIfAttributeDefined(builder, element, ENCODING_ATTRIBUTE);
NamespaceUtils.SetReferenceIfAttributeDefined(builder, element, MESSAGE_CONVERTER_ATTRIBUTE);
NamespaceUtils.SetReferenceIfAttributeDefined(builder, element, REPLY_QUEUE_ATTRIBUTE);
NamespaceUtils.SetValueIfAttributeDefined(builder, element, MANDATORY_ATTRIBUTE);
NamespaceUtils.SetValueIfAttributeDefined(builder, element, IMMEDIATE_ATTRIBUTE);
NamespaceUtils.SetReferenceIfAttributeDefined(builder, element, RETURN_CALLBACK_ATTRIBUTE);
NamespaceUtils.SetReferenceIfAttributeDefined(builder, element, CONFIRM_CALLBACK_ATTRIBUTE);
IObjectDefinition replyContainer = null;
XmlElement childElement = null;
var childElements = element.SelectChildElementsByTagName(LISTENER_ELEMENT);
if (childElements.Count > 0)
{
childElement = childElements[0] as XmlElement;
}
if (childElement != null)
{
replyContainer = this.ParseListener(childElement, element, parserContext);
if (replyContainer != null)
{
replyContainer.PropertyValues.Add("MessageListener", new RuntimeObjectReference(element.GetAttribute(ID_ATTRIBUTE)));
var replyContainerName = element.GetAttribute(ID_ATTRIBUTE) + ".ReplyListener";
parserContext.Registry.RegisterObjectDefinition(replyContainerName, replyContainer);
}
}
if (replyContainer == null && element.HasAttribute(REPLY_QUEUE_ATTRIBUTE))
{
parserContext.ReaderContext.ReportFatalException(element, "For template '" + element.GetAttribute(ID_ATTRIBUTE) + "', when specifying a reply-queue, a <reply-listener/> element is required");
}
else if (replyContainer != null && !element.HasAttribute(REPLY_QUEUE_ATTRIBUTE))
{
parserContext.ReaderContext.ReportFatalException(element, "For template '" + element.GetAttribute(ID_ATTRIBUTE) + "', a <reply-listener/> element is not allowed if no 'reply-queue' is supplied");
}
}
protected void DoParseInternal(XmlElement element, ObjectDefinitionBuilder builder)
{
builder.SetSingleton(false);
string leftMenu = element.GetAttribute("menu");
if(!string.IsNullOrEmpty(leftMenu)) builder.AddPropertyReference("Menu", leftMenu);
string rightScreen = element.GetAttribute("screen");
if(!string.IsNullOrEmpty(rightScreen)) builder.AddPropertyReference("MainScreen", rightScreen);
foreach (XmlNode node in element.ChildNodes)
{
if (node is XmlComment) continue;
switch (node.LocalName.ToLower())
{
case "steps":
XmlNodeList steps = node.ChildNodes;
if (steps.Count > 0) // if flow is configured with a list of steps
{
IDictionary stepsDic = new System.Collections.Hashtable();
int count = 0;
foreach (XmlNode step in steps)
{
if(step is XmlComment) continue;
if (!step.LocalName.ToLower().Equals("step"))
{
throw new Exception("Do not support node with name " + node.Name + " in config file.");
}
string key = "Step" + (++count).ToString();
stepsDic[key] = step.InnerText;
}
builder.AddPropertyValue("FlowSteps", stepsDic);
}
break;
case "session":
string sessionRefBeanName = node.InnerText;
if(!string.IsNullOrEmpty(sessionRefBeanName))
{
builder.AddDependsOn(sessionRefBeanName);
builder.AddPropertyReference("Session", sessionRefBeanName);
}
break;
case "menu":
string menuClassName = node.InnerText;
builder.AddPropertyValue("MenuClass", Type.GetType(menuClassName));
break;
case "screen":
string screenClassName = node.InnerText;
builder.AddPropertyValue("MainScreenClass", Type.GetType(screenClassName));
break;
default:
throw new Exception("Do not support node with name " + node.Name + " in config file.");
break;
}
}
}
/// <summary>The parse bindings.</summary>
/// <param name="element">The element.</param>
/// <param name="parserContext">The parser context.</param>
/// <param name="builder">The builder.</param>
/// <param name="exchangeName">The exchange name.</param>
protected override void ParseBindings(XmlElement element, ParserContext parserContext, ObjectDefinitionBuilder builder, string exchangeName)
{
var backingType = element.GetAttribute(BACKING_TYPE_ATTRIBUTE);
var bindings = element.SelectChildElementByTagName(DIRECT_BINDINGS_ELE);
if (bindings != null && ExchangeTypes.Direct != backingType)
{
parserContext.ReaderContext.ReportFatalException(element, "Cannot have direct-bindings if backing-type not 'direct'");
}
if (bindings == null)
{
bindings = element.SelectChildElementByTagName(TOPIC_BINDINGS_ELE);
if (bindings != null && !ExchangeTypes.Topic.Equals(backingType))
{
parserContext.ReaderContext.ReportFatalException(element, "Cannot have topic-bindings if backing-type not 'topic'");
}
}
if (bindings == null)
{
bindings = element.SelectChildElementByTagName(TOPIC_FANOUT_ELE);
if (bindings != null && !ExchangeTypes.Fanout.Equals(backingType))
{
parserContext.ReaderContext.ReportFatalException(element, "Cannot have fanout-bindings if backing-type not 'fanout'");
}
}
if (bindings == null)
{
bindings = element.SelectChildElementByTagName(TOPIC_HEADERS_ELE);
if (bindings != null && !ExchangeTypes.Headers.Equals(backingType))
{
parserContext.ReaderContext.ReportFatalException(element, "Cannot have headers-bindings if backing-type not 'headers'");
}
}
if (!string.IsNullOrWhiteSpace(backingType))
{
if (ExchangeTypes.Direct.Equals(backingType))
{
this.DoParseBindings(parserContext, exchangeName, bindings, new DirectExchangeParser());
}
else if (ExchangeTypes.Topic.Equals(backingType))
{
this.DoParseBindings(parserContext, exchangeName, bindings, new TopicExchangeParser());
}
else if (ExchangeTypes.Fanout.Equals(backingType))
{
this.DoParseBindings(parserContext, exchangeName, bindings, new FanoutExchangeParser());
}
else if (ExchangeTypes.Headers.Equals(backingType))
{
this.DoParseBindings(parserContext, exchangeName, bindings, new HeadersExchangeParser());
}
}
}
public void Simple()
{
GenericApplicationContext ctx = new GenericApplicationContext();
IObjectDefinitionFactory objectDefinitionFactory = new DefaultObjectDefinitionFactory();
ObjectDefinitionBuilder builder = ObjectDefinitionBuilder.RootObjectDefinition(objectDefinitionFactory,
typeof(TestObject));
builder.AddPropertyValue("Age", 22)
.AddPropertyValue("Name", "Joe")
.AddPropertyReference("Spouse", "Spouse")
.SetSingleton(false);
ctx.RegisterObjectDefinition("TestObject", builder.ObjectDefinition);
builder = ObjectDefinitionBuilder.RootObjectDefinition(objectDefinitionFactory, typeof(TestObject));
IList friends = new ArrayList();
friends.Add(new TestObject("Dan", 34));
friends.Add(new TestObject("Mary", 33));
builder.AddPropertyValue("Friends", friends)
.AddConstructorArg("Susan")
.AddConstructorArg(23)
.SetSingleton(false);
ctx.RegisterObjectDefinition("Spouse", builder.ObjectDefinition);
TestObject to = ctx.GetObject("TestObject") as TestObject;
Assert.IsNotNull(to);
Assert.AreEqual("Joe", to.Name);
Assert.AreEqual(22, to.Age);
Assert.AreEqual(2, to.Spouse.Friends.Count);
Assert.AreEqual(23, to.Spouse.Age);
/*
* AbstractApplicationContext ctx = ContextRegistry.GetContext() as AbstractApplicationContext;
*
*
*
* //XmlObjectFactory objectFactory = ctx.ObjectFactory as XmlObjectFactory;
*
* IObjectFactory objectFactory = ctx.ObjectFactory;
*
* //DefaultListableObjectFactory
* if (objectFactory != null)
* {
* Console.WriteLine("hi");
* }
* //objectFactory.RegisterObjectDefinition("TestObject", builder.ObjectDefinition);
*/
}
/*override*/
protected static void PostProcess(ObjectDefinitionBuilder builder, XmlElement element)
{
string policyName = element.GetAttribute(REJECTION_POLICY_ATTRIBUTE);
builder.AddPropertyValue("rejectedExecutionHandler", CreateRejectedExecutionHandler(policyName));
builder.AddPropertyValue("corePoolSize", element.GetAttribute(CORE_SIZE_ATTRIBUTE));
string maxSize = element.GetAttribute(MAX_SIZE_ATTRIBUTE);
if(StringUtils.HasText(maxSize)) {
builder.AddPropertyValue("maxPoolSize", maxSize);
}
}
/// <summary>
/// Parse the supplied XmlElement and populate the supplied ObjectDefinitionBuilder as required.
/// </summary>
/// <param name="xml">The obejct representation in XML.</param>
/// <param name="builder">The builder used to build the object definition in Spring.</param>
protected override void DoParse(XmlElement xml, ObjectDefinitionBuilder builder)
{
// all behaviours with config being parsed have @respondsTo
string respondsTo = xml.GetAttribute("responds-to");
builder.AddConstructorArg(respondsTo);
// all view behaviours have @content-type
string contentType = xml.GetAttribute("content-type");
builder.AddConstructorArg(contentType);
}
/// <summary>Adds the constructor arg value if attribute defined.</summary>
/// <param name="builder">The builder.</param>
/// <param name="element">The element.</param>
/// <param name="attributeName">Name of the attribute.</param>
/// <returns><c>true</c> if [is attribute defined] [the specified element]; otherwise, <c>false</c>.</returns>
public static bool AddConstructorArgValueIfAttributeDefined(ObjectDefinitionBuilder builder, XmlElement element, string attributeName)
{
var value = element.GetAttribute(attributeName);
if (!string.IsNullOrWhiteSpace(value))
{
builder.AddConstructorArg(new TypedStringValue(value));
return true;
}
return false;
}
public void ObjectTypeWithFactoryMethod()
{
ObjectDefinitionBuilder odb =
ObjectDefinitionBuilder.RootObjectDefinition(odf, typeof(TestObject), "Create");
RootObjectDefinition rod = odb.ObjectDefinition as RootObjectDefinition;
Assert.IsNotNull(rod);
Assert.IsTrue(rod.HasObjectType);
Assert.AreEqual(typeof(TestObject), rod.ObjectType);
Assert.AreEqual("Create", rod.FactoryMethodName);
}
/// <summary>Sets the value if attribute defined.</summary>
/// <param name="builder">The builder.</param>
/// <param name="element">The element.</param>
/// <param name="attributeName">Name of the attribute.</param>
/// <param name="propertyName">Name of the property.</param>
/// <returns>True if successful, else false.</returns>
public static bool SetValueIfAttributeDefined(ObjectDefinitionBuilder builder, XmlElement element, string attributeName, string propertyName)
{
var attributeValue = element.GetAttribute(attributeName);
if (!string.IsNullOrWhiteSpace(attributeValue))
{
builder.AddPropertyValue(propertyName, new TypedStringValue(attributeValue));
return true;
}
return false;
}
protected override void DoParse(XmlElement element, ObjectDefinitionBuilder builder)
{
foreach(XmlAttribute attribute in element.Attributes) {
if(IsEligibleAttribute(attribute.Name)) {
string propertyName = Conventions.AttributeNameToPropertyName(attribute.LocalName);
AssertUtils.State(StringUtils.HasText(propertyName), "Illegal property name returned from 'extractPropertyName(String)': cannot be null or empty.");
builder.AddPropertyValue(propertyName, attribute.Value);
}
}
PostProcess(builder, element);
}
/*override*/
protected void PostProcess(ObjectDefinitionBuilder builder, XmlElement element)
{
string requestChannelRef = element.GetAttribute("request-channel");
if(!StringUtils.HasText(requestChannelRef))
throw new ArgumentException("a 'request-channel' reference is required");
builder.AddPropertyReference("requestChannel", requestChannelRef);
string replyChannel = element.GetAttribute("reply-channel");
if(StringUtils.HasText(replyChannel)) {
builder.AddPropertyReference("replyChannel", replyChannel);
}
DoPostProcess(builder, element);
}
/// <summary>
/// Create a new <code>ObjectDefinitionBuilder</code> used to construct a child object definition..
/// </summary>
/// <param name="objectDefinitionFactory">The object definition factory.</param>
/// <param name="parentObjectName">Name of the parent object.</param>
/// <returns></returns>
public static ObjectDefinitionBuilder ChildObjectDefinition(IObjectDefinitionFactory objectDefinitionFactory,
string parentObjectName)
{
ObjectDefinitionBuilder builder = new ObjectDefinitionBuilder();
builder.objectDefinitionFactory = objectDefinitionFactory;
builder.objectDefinition =
objectDefinitionFactory.CreateObjectDefinition(null, parentObjectName, AppDomain.CurrentDomain);
return(builder);
}
protected override void DoParse(XmlElement element, ParserContext parserContext, ObjectDefinitionBuilder builder)
{
String taskExecutorRef = element.GetAttribute("task-executor");
if(StringUtils.HasText(taskExecutorRef)) {
builder.AddPropertyReference("taskExecutor", taskExecutorRef);
}
else {
IExecutor taskExecutor = IntegrationContextUtils.CreateThreadPoolTaskExecutor(1, 10, 0, "event-multicaster-");
builder.AddPropertyValue("taskExecutor", taskExecutor);
}
// TODO CopyOnWriteArraySet
builder.AddPropertyValue("collectionClass", typeof (Set)); //CopyOnWriteArraySet));
}
public static object ParseRefOrNestedObjectDeclaration(ParserContext parserContext, XmlElement element,
ObjectDefinitionBuilder builder, string refAttrName)
{
String attr = element.GetAttribute(refAttrName);
bool hasRef = StringUtils.HasText(attr);
XmlNodeList childNodes = element.ChildNodes;
if (hasRef)
{
if (childNodes.Count > 0)
{
//"either use the '" + refAttrName + "' attribute or a nested object declaration for '"
//+ element.getLocalName() + "' element, but not both", element);
parserContext.ReaderContext.ReportException(element, element.LocalName,
"either use the '" + refAttrName +
"' attribute or a nested object declaration for '"
+ element.LocalName + "' element, but not both");
}
return new RuntimeObjectReference(attr);
}
if (childNodes.Count == 0)
{
parserContext.ReaderContext.ReportException(element, element.LocalName,
"specify either '" + refAttrName +
"' attribute or a nested object declaration for '"
+ element.LocalName + "' element");
}
// nested parse nested object definition
if (childNodes.Count == 1)
{
if (childNodes[0].NodeType == XmlNodeType.Element)
{
XmlElement childElement = (XmlElement) childNodes[0];
return ParsePropertySubElement(childElement, builder.RawObjectDefinition, parserContext);
}
}
ManagedList list = new ManagedList();
for (int i = 0; i < childNodes.Count; i++)
{
XmlNode childNode = childNodes.Item(i);
if (childNode != null && childNode.NodeType == XmlNodeType.Element)
{
list.Add(ParsePropertySubElement((XmlElement) childNode, builder.RawObjectDefinition, parserContext));
}
}
return list;
}
/// <summary>
/// Create a new <code>ObjectDefinitionBuilder</code> used to construct a root object definition.
/// </summary>
/// <param name="objectDefinitionFactory">The object definition factory.</param>
/// <param name="objectType">Type of the object.</param>
/// <param name="factoryMethodName">Name of the factory method.</param>
/// <returns>A new <code>ObjectDefinitionBuilder</code> instance.</returns>
public static ObjectDefinitionBuilder RootObjectDefinition(IObjectDefinitionFactory objectDefinitionFactory,
Type objectType, string factoryMethodName)
{
ObjectDefinitionBuilder builder = new ObjectDefinitionBuilder();
builder.objectDefinitionFactory = objectDefinitionFactory;
builder.objectDefinition =
objectDefinitionFactory.CreateObjectDefinition(objectType.FullName, null, AppDomain.CurrentDomain);
builder.objectDefinition.ObjectType = objectType;
builder.objectDefinition.FactoryMethodName = factoryMethodName;
return(builder);
}
/// <summary>
/// Create a new <code>ObjectDefinitionBuilder</code> used to construct a root object definition.
/// </summary>
/// <param name="objectDefinitionFactory">The object definition factory.</param>
/// <param name="objectTypeName">Name of the object type.</param>
/// <param name="factoryMethodName">Name of the factory method.</param>
/// <returns>A new <code>ObjectDefinitionBuilder</code> instance.</returns>
public static ObjectDefinitionBuilder RootObjectDefinition(IObjectDefinitionFactory objectDefinitionFactory,
string objectTypeName,
string factoryMethodName)
{
ObjectDefinitionBuilder builder = new ObjectDefinitionBuilder();
builder.objectDefinitionFactory = objectDefinitionFactory;
// Pass in null for parent name and also AppDomain to force object definition to be register by name and not type.
builder.objectDefinition =
objectDefinitionFactory.CreateObjectDefinition(objectTypeName, null, null);
builder.objectDefinition.FactoryMethodName = factoryMethodName;
return(builder);
}
/// <summary>The do parse.</summary>
/// <param name="element">The element.</param>
/// <param name="parserContext">The parser context.</param>
/// <param name="builder">The builder.</param>
protected override void DoParse(XmlElement element, ParserContext parserContext, ObjectDefinitionBuilder builder)
{
if (!NamespaceUtils.IsAttributeDefined(element, "name") && !NamespaceUtils.IsAttributeDefined(element, ID_ATTRIBUTE))
{
parserContext.ReaderContext.ReportFatalException(element, "Queue must have either id or name (or both)");
}
NamespaceUtils.AddConstructorArgValueIfAttributeDefined(builder, element, "name");
if (!NamespaceUtils.IsAttributeDefined(element, "name"))
{
if (this.AttributeHasIllegalOverride(element, DURABLE_ATTRIBUTE, "false")
|| this.AttributeHasIllegalOverride(element, EXCLUSIVE_ATTRIBUTE, "true")
|| this.AttributeHasIllegalOverride(element, AUTO_DELETE_ATTRIBUTE, "true"))
{
parserContext.ReaderContext.ReportFatalException(element, "Anonymous queue cannot specify durable='true', exclusive='false' or auto-delete='false'");
return;
}
}
else
{
NamespaceUtils.AddConstructorArgBooleanValueIfAttributeDefined(builder, element, DURABLE_ATTRIBUTE, false);
NamespaceUtils.AddConstructorArgBooleanValueIfAttributeDefined(builder, element, EXCLUSIVE_ATTRIBUTE, false);
NamespaceUtils.AddConstructorArgBooleanValueIfAttributeDefined(builder, element, AUTO_DELETE_ATTRIBUTE, false);
}
var queueArguments = element.GetAttribute(ARGUMENTS);
var argumentsElement = element.SelectChildElementByTagName(ARGUMENTS);
if (argumentsElement != null)
{
var parser = new ObjectDefinitionParserHelper(parserContext);
if (!string.IsNullOrWhiteSpace(queueArguments))
{
parserContext.ReaderContext.ReportFatalException(element, "Queue may have either a queue-attributes attribute or element, but not both");
}
var map = parser.ParseMapElement(argumentsElement, builder.RawObjectDefinition);
builder.AddConstructorArg(map);
}
if (!string.IsNullOrWhiteSpace(queueArguments))
{
builder.AddConstructorArgReference(queueArguments);
}
}
/// <summary>
/// Parse a "poller" element to provide a reference for the target
/// ObjectDefinitionBuilder. If the poller element does not contain a "ref"
/// attribute, this will create and register a PollerMetadata instance and
/// then add it as a property reference of the target builder.
/// </summary>
/// <param name="pollerElement">the "poller" element to parse</param>
/// <param name="targetBuilder">the builder that expects the "trigger" property</param>
/// <param name="parserContext">the parserContext for the target builder</param>
public static void ConfigurePollerMetadata(XmlElement pollerElement, ObjectDefinitionBuilder targetBuilder, ParserContext parserContext)
{
string pollerMetadataRef;
if(pollerElement.HasAttribute("ref")) {
if(pollerElement.Attributes.Count != 1) {
parserContext.ReaderContext.ReportException(pollerElement, "poller", "A 'poller' element that provides a 'ref' must have no other attributes.");
}
if(pollerElement.ChildNodes.Count != 0) {
parserContext.ReaderContext.ReportException(pollerElement, "poller", "A 'poller' element that provides a 'ref' must have no child elements.");
}
pollerMetadataRef = pollerElement.GetAttribute("ref");
}
else {
IObjectDefinition pollerDef = parserContext.ParserHelper.ParseCustomElement(pollerElement, targetBuilder.ObjectDefinition);
pollerMetadataRef = parserContext.ReaderContext.RegisterWithGeneratedName(pollerDef);
}
targetBuilder.AddPropertyReference("pollerMetadata", pollerMetadataRef);
}
private void SetConvention(XmlElement element, ObjectDefinitionBuilder builder, string attribute, string property)
{
string value = string.Empty;
try
{
value = element.GetAttribute(attribute);
if (StringUtils.HasText(value))
{
Type type = TypeResolutionUtils.ResolveType(value);
object instance = Activator.CreateInstance(type);
builder.AddPropertyValue(property, instance);
}
}
catch (TypeLoadException e)
{
throw new ObjectCreationException(string.Format("Convention of type '{0}' could not be loaded: {1}", attribute, value));
}
}
public void ObjectTypeWithSimpleProperty()
{
string[] dependsOn = new string[] { "A", "B", "C" };
ObjectDefinitionBuilder odb = ObjectDefinitionBuilder.RootObjectDefinition(odf, typeof(TestObject));
odb.SetSingleton(false).AddPropertyReference("Age", "15");
foreach (string dep in dependsOn)
{
odb.AddDependsOn(dep);
}
RootObjectDefinition rod = odb.ObjectDefinition as RootObjectDefinition;
Assert.IsNotNull(rod);
Assert.IsFalse(rod.IsSingleton);
Assert.AreEqual(typeof(TestObject), rod.ObjectType);
Assert.AreEqual(dependsOn, rod.DependsOn, "DependsOn not as expected");
Assert.IsTrue(rod.PropertyValues.Contains("Age"));
}
/// <summary>The do parse.</summary>
/// <param name="element">The element.</param>
/// <param name="parserContext">The parser context.</param>
/// <param name="builder">The builder.</param>
protected override void DoParse(XmlElement element, ParserContext parserContext, ObjectDefinitionBuilder builder)
{
var exchangeName = element.GetAttribute("name");
builder.AddConstructorArg(new TypedStringValue(exchangeName));
this.ParseBindings(element, parserContext, builder, exchangeName);
NamespaceUtils.AddConstructorArgBooleanValueIfAttributeDefined(builder, element, DURABLE_ATTRIBUTE, true);
NamespaceUtils.AddConstructorArgBooleanValueIfAttributeDefined(builder, element, AUTO_DELETE_ATTRIBUTE, false);
var argumentsElement = element.SelectChildElementByTagName(ARGUMENTS_ELEMENT);
if (argumentsElement != null)
{
var parser = new ObjectDefinitionParserHelper(parserContext);
var map = parser.ParseMapElementToTypedDictionary(argumentsElement, builder.RawObjectDefinition);
builder.AddConstructorArg(map);
}
}
/// <summary>The do parse.</summary>
/// <param name="element">The element.</param>
/// <param name="parserContext">The parser context.</param>
/// <param name="builder">The builder.</param>
protected override void DoParse(XmlElement element, ParserContext parserContext, ObjectDefinitionBuilder builder)
{
if (element.HasAttribute(ADDRESSES) && (element.HasAttribute(HOST_ATTRIBUTE) || element.HasAttribute(PORT_ATTRIBUTE)))
{
parserContext.ReaderContext.ReportFatalException(element, "If the 'addresses' attribute is provided, a connection factory can not have 'host' or 'port' attributes.");
}
NamespaceUtils.AddConstructorArgParentRefIfAttributeDefined(builder, element, CONNECTION_FACTORY_ATTRIBUTE);
NamespaceUtils.SetValueIfAttributeDefined(builder, element, CHANNEL_CACHE_SIZE_ATTRIBUTE);
NamespaceUtils.SetValueIfAttributeDefined(builder, element, HOST_ATTRIBUTE);
NamespaceUtils.SetValueIfAttributeDefined(builder, element, PORT_ATTRIBUTE);
NamespaceUtils.SetValueIfAttributeDefined(builder, element, USER_ATTRIBUTE);
NamespaceUtils.SetValueIfAttributeDefined(builder, element, PASSWORD_ATTRIBUTE);
NamespaceUtils.SetValueIfAttributeDefined(builder, element, VIRTUAL_HOST_ATTRIBUTE);
// TODO: Currently no .NET equivalent to the Java Task Executor that can be used by RabbitMQ.Client
// NamespaceUtils.SetReferenceIfAttributeDefined(builder, element, EXECUTOR_ATTRIBUTE);
NamespaceUtils.SetValueIfAttributeDefined(builder, element, ADDRESSES);
NamespaceUtils.SetValueIfAttributeDefined(builder, element, PUBLISHER_CONFIRMS);
NamespaceUtils.SetValueIfAttributeDefined(builder, element, PUBLISHER_RETURNS);
}
/// <summary>The do parse.</summary>
/// <param name="element">The element.</param>
/// <param name="parserContext">The parser context.</param>
/// <param name="builder">The builder.</param>
protected override void DoParse(XmlElement element, ParserContext parserContext, ObjectDefinitionBuilder builder)
{
var connectionFactoryRef = element.GetAttribute(CONNECTION_FACTORY_ATTRIBUTE);
// At least one of 'templateRef' or 'connectionFactoryRef' attribute must be set.
if (string.IsNullOrWhiteSpace(connectionFactoryRef))
{
parserContext.ReaderContext.ReportFatalException(element, "A '" + CONNECTION_FACTORY_ATTRIBUTE + "' attribute must be set.");
}
if (!string.IsNullOrWhiteSpace(connectionFactoryRef))
{
// Use constructor with connectionFactory parameter
builder.AddConstructorArgReference(connectionFactoryRef);
}
var attributeValue = element.GetAttribute(AUTO_STARTUP_ATTRIBUTE);
if (!string.IsNullOrWhiteSpace(attributeValue))
{
builder.AddPropertyValue("AutoStartup", attributeValue);
}
}
private void ParseSelectorChain(ObjectDefinitionBuilder builder, XmlElement element, ParserContext parserContext)
{
IntegrationNamespaceUtils.SetValueIfAttributeDefined(builder, element, "voting-strategy");
ManagedList selectors = new ManagedList();
selectors.ElementTypeName = typeof (IMessageSelector).FullName;
XmlNodeList childNodes = element.ChildNodes;
for(int i = 0; i < childNodes.Count; i++) {
XmlNode child = childNodes.Item(i);
if(child.NodeType == XmlNodeType.Element) {
string nodeName = child.LocalName;
if("selector".Equals(nodeName)) {
string refatr = ((XmlElement)child).GetAttribute("ref");
selectors.Add(new RuntimeObjectReference(refatr));
}
else if("selector-chain".Equals(nodeName)) {
ObjectDefinitionBuilder nestedBuilder = ObjectDefinitionBuilder.GenericObjectDefinition(GetObjectTypeName(null));
ParseSelectorChain(nestedBuilder, (XmlElement)child, parserContext);
string nestedBeanName = parserContext.ReaderContext.RegisterWithGeneratedName(nestedBuilder.ObjectDefinition);
selectors.Add(new RuntimeObjectReference(nestedBeanName));
}
}
}
builder.AddPropertyValue("selectors", selectors);
}
/// <summary>
/// Populates the object definition property corresponding to the specified
/// attributeName with the value of that attribute if it is defined in the
/// given element.
///
/// <p>The property name will be the camel-case equivalent of the lower
/// case hyphen separated attribute (e.g. the "foo-bar" attribute would
/// match the "fooBar" property).
/// <see cref="Conventions.AttributeNameToPropertyName"/>
/// </summary>
/// <param name="builder">the builder</param>
/// <param name="element">the XML element where the attribute should be defined</param>
/// <param name="attributeName">the name of the attribute whose value will be set</param>
public static void SetValueIfAttributeDefined(ObjectDefinitionBuilder builder, XmlElement element, string attributeName)
{
SetValueIfAttributeDefined(builder, element, attributeName, Conventions.AttributeNameToPropertyName(attributeName));
}