Example usage for org.springframework.beans.factory.support ManagedSet ManagedSet

List of usage examples for org.springframework.beans.factory.support ManagedSet ManagedSet

  1. HOME
  2. Java
  3. org.springframework
  4. org.springframework.beans.factory.support.*
  5. ManagedSet
  6. ManagedSet

Introduction

In this page you can find the example usage for org.springframework.beans.factory.support ManagedSet ManagedSet.

Prototype

public ManagedSet()

Source Link

Usage

From source file:org.opencredo.esper.config.xml.EsperListenerParser.java

/**
 * Parses out a set of configured esper statement listeners.
 * //from w w  w  .  j av  a 2 s . c om
 * @param element
 *            the esper listeners element
 * @param parserContext
 *            the parser's current context
 * @return a list of configured esper statement listeners
 */
@SuppressWarnings("unchecked")
public ManagedSet parseListeners(Element element, ParserContext parserContext) {
    ManagedSet listeners = new ManagedSet();
    NodeList childNodes = element.getChildNodes();
    for (int i = 0; i < childNodes.getLength(); i++) {
        Node child = childNodes.item(i);
        if (child.getNodeType() == Node.ELEMENT_NODE) {
            Element childElement = (Element) child;
            String localName = child.getLocalName();
            if ("bean".equals(localName)) {
                BeanDefinitionHolder holder = parserContext.getDelegate()
                        .parseBeanDefinitionElement(childElement);
                parserContext.registerBeanComponent(new BeanComponentDefinition(holder));
                listeners.add(new RuntimeBeanReference(holder.getBeanName()));
            } else if ("ref".equals(localName)) {
                String ref = childElement.getAttribute("bean");
                listeners.add(new RuntimeBeanReference(ref));
            }
        }
    }
    return listeners;
}

From source file:biz.c24.io.spring.config.C24HttpMessageConverterBeanDefinitionParser.java

@Override
protected AbstractBeanDefinition parseInternal(Element element, ParserContext context) {

    Object source = context.extractSource(element);

    String modelRef = element.getAttribute("model-ref");
    modelRef = StringUtils.hasText(modelRef) ? modelRef : C24ModelBeanDefinitionParser.DEFAULT_BEAN_NAME;

    Set<BeanDefinition> formats = new ManagedSet<BeanDefinition>();
    for (Element formatElement : DomUtils.getChildElementsByTagName(element, "format")) {
        formats.add(formatParser.parse(formatElement, context));
    }/*  w w  w  .j  av a 2  s . co  m*/

    // Create C24HttpMessageConverter bean
    BeanDefinitionBuilder builder = BeanDefinitionBuilder.rootBeanDefinition(C24HttpMessageConverter.class);
    builder.addConstructorArgReference(modelRef);
    builder.addConstructorArgValue(formats);

    return getSourcedBeanDefinition(builder, source);
}

From source file:jeeves.server.overrides.AddPropertyUpdater.java

@SuppressWarnings("unchecked")
@Override//from w w  w  .  ja va  2  s .c  o m
protected void doUpdate(ConfigurableListableBeanFactory beanFactory, BeanDefinition bean, Object value) {
    Log.debug(Log.JEEVES, "Adding new value " + value + " to property: " + propertyName + " on " + beanName);
    PropertyValue propertyValue = bean.getPropertyValues().getPropertyValue(propertyName);
    if (propertyValue == null) {
        final String beanClassName = bean.getBeanClassName();
        try {
            final Class<?> aClass = Class.forName(beanClassName);
            final PropertyDescriptor[] propertyDescriptors = PropertyUtils.getPropertyDescriptors(aClass);
            for (PropertyDescriptor descriptor : propertyDescriptors) {
                if (propertyName.equals(descriptor.getName())) {
                    final Class<?> collectionType = descriptor.getWriteMethod().getParameterTypes()[0];
                    if (List.class.isAssignableFrom(collectionType)) {
                        propertyValue = new PropertyValue(propertyName, new ManagedList<Object>());
                    } else if (Set.class.isAssignableFrom(collectionType)) {
                        propertyValue = new PropertyValue(propertyName, new ManagedSet<Object>());
                    } else if (Map.class.isAssignableFrom(collectionType)) {
                        propertyValue = new PropertyValue(propertyName, new ManagedMap<Object, Object>());
                    } else if (Properties.class.isAssignableFrom(collectionType)) {
                        propertyValue = new PropertyValue(propertyName, new ManagedProperties());
                    } else if (Array.class.isAssignableFrom(collectionType)) {
                        throw new IllegalArgumentException("Array collections not currently supported");
                    } else if (Collection.class.isAssignableFrom(collectionType)) {
                        propertyValue = new PropertyValue(propertyName, new ManagedList<Object>());
                    } else {
                        throw new IllegalArgumentException(
                                collectionType + " is not a supported type for adding new values");
                    }
                    break;
                }
            }
            if (propertyValue == null) {
                throw new IllegalArgumentException("Unable to find the collection type for property: "
                        + propertyName + " on bean " + beanName);
            }
            bean.getPropertyValues().addPropertyValue(propertyValue);
        } catch (ClassNotFoundException e) {
            throw new AssertionError(e);
        }
    }

    Object originalValue = propertyValue.getValue();
    if (originalValue instanceof Collection) {
        Collection<Object> coll = (Collection<Object>) originalValue;
        coll.add(value);
    } else {
        throw new IllegalArgumentException(originalValue + " is not a collection as expected");
    }
}

From source file:org.opencredo.esper.config.xml.EsperStatementParser.java

/**
 * Parses out the individual statement elements for further processing.
 * //from ww  w .j a  va  2  s. co  m
 * @param element
 *            the esper-template context
 * @param parserContext
 *            the parser's context
 * @return a set of initialized esper statements
 */
@SuppressWarnings("unchecked")
public ManagedSet parseStatements(Element element, ParserContext parserContext) {
    ManagedSet statements = new ManagedSet();
    NodeList childNodes = element.getChildNodes();
    for (int i = 0; i < childNodes.getLength(); i++) {

        Node child = childNodes.item(i);

        if (child.getNodeType() == Node.ELEMENT_NODE) {

            Element childElement = (Element) child;

            String localName = child.getLocalName();

            if ("statement".equals(localName)) {

                BeanDefinition definition = parserContext.getDelegate().parseCustomElement(childElement);
                statements.add(definition);
            } else if ("ref".equals(localName)) {
                String ref = childElement.getAttribute("bean");
                statements.add(new RuntimeBeanReference(ref));
            }
        }
    }
    return statements;
}

From source file:de.acosix.alfresco.mtsupport.repo.beans.TemplatedTenantBeanEmitter.java

protected void shallowCloneManagedCollections(final AbstractBeanDefinition cloneBeanDefinition) {
    // clone is not a deep clone - managed lists / maps are by-reference which is problematic for placeholder resolution
    final MutablePropertyValues propertyValues = cloneBeanDefinition.getPropertyValues();
    for (final PropertyValue pv : propertyValues.getPropertyValues()) {
        final Object value = pv.getValue();
        if (value instanceof ManagedList<?>) {
            final ManagedList<Object> newList = new ManagedList<>();
            newList.setSource(((ManagedList<?>) value).getSource());
            newList.setElementTypeName(((ManagedList<?>) value).getElementTypeName());
            newList.addAll((ManagedList<?>) value);
            propertyValues.add(pv.getName(), newList);
        } else if (value instanceof ManagedSet<?>) {
            final ManagedSet<Object> newSet = new ManagedSet<>();
            newSet.setSource(((ManagedSet<?>) value).getSource());
            newSet.setElementTypeName(((ManagedSet<?>) value).getElementTypeName());
            newSet.addAll((ManagedSet<?>) value);
            propertyValues.add(pv.getName(), newSet);
        } else if (value instanceof ManagedMap<?, ?>) {
            final ManagedMap<Object, Object> newMap = new ManagedMap<>();
            newMap.setSource(((ManagedMap<?, ?>) value).getSource());
            newMap.setKeyTypeName(((ManagedMap<?, ?>) value).getKeyTypeName());
            newMap.setValueTypeName(((ManagedMap<?, ?>) value).getValueTypeName());
            newMap.putAll((ManagedMap<?, ?>) value);
            propertyValues.add(pv.getName(), newMap);
        }//w ww  .  ja  v  a 2  s.c  o m
    }
}

From source file:de.acosix.alfresco.utility.common.spring.PropertyAlteringBeanFactoryPostProcessor.java

protected Object handleSetValues(final PropertyValue configuredValue) {
    final Object value;
    LOGGER.debug(/*from   ww w .ja v a  2 s  . c  o m*/
            "[{}] Set of values / bean reference names has been configured - treating property {} of {} as <set>",
            this.beanName, this.propertyName, this.targetBeanName);

    final ManagedSet<Object> set = new ManagedSet<>();

    if (this.merge && configuredValue != null) {
        final Object configuredValueDefinition = configuredValue.getValue();
        if (configuredValueDefinition instanceof ManagedSet<?>) {
            final ManagedSet<?> oldSet = (ManagedSet<?>) configuredValueDefinition;
            set.setElementTypeName(oldSet.getElementTypeName());
            set.setMergeEnabled(oldSet.isMergeEnabled());
            set.setSource(oldSet.getSource());

            set.addAll(oldSet);

            LOGGER.debug("[{}] Merged existing value set values: {}", this.beanName, oldSet);
        }
    }

    Set<Object> valuesToAdd;
    if (this.valueSet != null) {
        LOGGER.debug("[{}] Set of configured values for {} of {}: ", this.beanName, this.propertyName,
                this.targetBeanName, this.valueSet);
        valuesToAdd = this.valueSet;
    } else {
        LOGGER.debug("[{}] Set of configured bean reference names for {} of {}: ", this.beanName,
                this.propertyName, this.targetBeanName, this.beanReferenceNameSet);
        valuesToAdd = new HashSet<>();
        for (final String beanReferenceName : this.beanReferenceNameSet) {
            valuesToAdd.add(new RuntimeBeanReference(beanReferenceName));
        }
    }

    LOGGER.debug("[{}] Adding new entries to set for {} of {}", this.beanName, this.propertyName,
            this.targetBeanName);
    set.addAll(valuesToAdd);

    if (!set.isMergeEnabled() && this.mergeParent) {
        LOGGER.debug("[{}] Enabling \"merge\" for <set> on {} of {}", this.beanName, this.propertyName,
                this.targetBeanName);
    }
    set.setMergeEnabled(set.isMergeEnabled() || this.mergeParent);
    value = set;
    return value;
}

From source file:de.acosix.alfresco.utility.common.spring.BeanDefinitionFromPropertiesPostProcessor.java

@SuppressWarnings("unchecked")
protected ManagedSet<Object> initSetPropertyValue(final String beanName, final String propertyName,
        final MutablePropertyValues propertyValues) {
    ManagedSet<Object> valueSet;
    PropertyValue propertyValue = propertyValues.getPropertyValue(propertyName);
    if (propertyValue == null) {
        LOGGER.trace("[{}] Property {} on {} not defined yet - initializing new managed set", this.beanName,
                beanName, propertyName);
        valueSet = new ManagedSet<>();
        propertyValue = new PropertyValue(propertyName, valueSet);
        propertyValues.addPropertyValue(propertyValue);
    } else if (propertyValue.getValue() instanceof ManagedList<?>) {
        LOGGER.trace("[{}] Property {} on {} already has a set value - amending", this.beanName, beanName,
                propertyName);/*from   w w w. ja  va  2  s  .c o  m*/
        valueSet = (ManagedSet<Object>) propertyValue.getValue();
    } else {
        LOGGER.debug(
                "[{}] Property {} on {} already defined with value {} - overriding with set value based on properties",
                this.beanName, beanName, propertyName, propertyValue.getValue());
        valueSet = new ManagedSet<>();
        propertyValue = new PropertyValue(propertyName, valueSet);
        propertyValues.addPropertyValue(propertyValue);
    }
    return valueSet;
}

From source file:org.kuali.rice.krad.datadictionary.DictionaryBeanFactoryPostProcessor.java

/**
 * Iterates through the set values and calls helpers to process the value
 *
 * @param setVal the set to process//from   ww w .  j a  v  a2s.c o m
 * @param propertyName name of the property which has the set value
 * @param nestedBeanStack stack of bean containers which contains the set property
 */
protected void visitSet(Set setVal, String propertyName, Stack<BeanDefinitionHolder> nestedBeanStack) {
    boolean isMergeEnabled = false;
    if (setVal instanceof ManagedSet) {
        isMergeEnabled = ((ManagedSet) setVal).isMergeEnabled();
    }

    ManagedSet newSet = new ManagedSet();
    newSet.setMergeEnabled(isMergeEnabled);

    for (Object elem : setVal) {
        if (isStringValue(elem)) {
            elem = processSetStringPropertyValue(propertyName, setVal, getString(elem), nestedBeanStack,
                    beanProcessors);
        } else {
            elem = visitPropertyValue(propertyName, elem, nestedBeanStack);
        }

        newSet.add(elem);
    }

    setVal.clear();
    setVal.addAll(newSet);
}

From source file:org.kuali.rice.krad.datadictionary.parse.CustomSchemaParser.java

/**
 * Parses a list of elements into a set of beans/standard content.
 *
 * @param grandChildren - The set of beans/content in a bean property
 * @param child - The property tag for the parent.
 * @param parent - The parent bean that the tag is nested in.
 * @param parserContext - Provided information and functionality regarding current bean set.
 * @return A managedSet of the nested content.
 *///ww w .  j a  v a 2  s. co m
protected ManagedSet parseSet(ArrayList<Element> grandChildren, Element child, BeanDefinitionBuilder parent,
        ParserContext parserContext) {
    ManagedSet setItems = new ManagedSet();

    for (int i = 0; i < grandChildren.size(); i++) {
        Element grandChild = grandChildren.get(i);

        if (child.getTagName().compareTo("value") == 0) {
            setItems.add(grandChild.getTextContent());
        } else {
            setItems.add(parseBean(grandChild, parent, parserContext));
        }
    }

    String merge = child.getAttribute("merge");
    if (merge != null) {
        setItems.setMergeEnabled(Boolean.valueOf(merge));
    }

    return setItems;
}

From source file:org.kuali.rice.krad.datadictionary.uif.UifBeanFactoryPostProcessor.java

@SuppressWarnings("unchecked")
protected void visitSet(String propertyName, Map<String, String> parentPropertyExpressions,
        Map<String, String> propertyExpressions, Set setVal, ConfigurableListableBeanFactory beanFactory,
        Set<String> processedBeanNames) {
    boolean isMergeEnabled = false;
    if (setVal instanceof ManagedSet) {
        isMergeEnabled = ((ManagedSet) setVal).isMergeEnabled();
    }//from  w ww . java2 s  . c  o m

    ManagedSet newSet = new ManagedSet();
    newSet.setMergeEnabled(isMergeEnabled);

    for (Object elem : setVal) {
        if (hasExpression(elem)) {
            String strValue = getStringValue(elem);
            propertyExpressions.put(propertyName + ExpressionEvaluator.EMBEDDED_PROPERTY_NAME_ADD_INDICATOR,
                    strValue);
        } else {
            // process set value bean definition as a top level bean
            if ((elem instanceof BeanDefinition) || (elem instanceof BeanDefinitionHolder)) {
                String beanName = null;
                BeanDefinition beanDefinition;
                if (elem instanceof BeanDefinition) {
                    beanDefinition = (BeanDefinition) elem;
                } else {
                    beanDefinition = ((BeanDefinitionHolder) elem).getBeanDefinition();
                    beanName = ((BeanDefinitionHolder) elem).getBeanName();
                }

                processBeanDefinition(beanName, beanDefinition, beanFactory, processedBeanNames);
            }

            newSet.add(elem);
        }
    }

    // determine if we need to clear any parent expressions for this list
    if (!isMergeEnabled) {
        // clear any expressions that match the property name minus index
        Map<String, String> adjustedParentExpressions = new HashMap<String, String>();
        for (Map.Entry<String, String> parentExpression : parentPropertyExpressions.entrySet()) {
            if (!parentExpression.getKey()
                    .startsWith(propertyName + ExpressionEvaluator.EMBEDDED_PROPERTY_NAME_ADD_INDICATOR)) {
                adjustedParentExpressions.put(parentExpression.getKey(), parentExpression.getValue());
            }
        }

        parentPropertyExpressions.clear();
        parentPropertyExpressions.putAll(adjustedParentExpressions);
    }

    setVal.clear();
    setVal.addAll(newSet);
}