Example usage for org.dom4j Element attributeValue

List of usage examples for org.dom4j Element attributeValue

  1. HOME
  2. Java
  3. org.dom4j
  4. org.dom4j.*
  5. Element
  6. attributeValue

Introduction

In this page you can find the example usage for org.dom4j Element attributeValue.

Prototype

String attributeValue(QName qName);

Source Link

Document

This returns the attribute value for the attribute with the given fully qualified name or null if there is no such attribute or the empty string if the attribute value is empty.

Usage

From source file:com.dji.bricks.node_selection.UiAutomatorModel.java

License:Apache License

public UiAutomatorModel(File xmlDumpFile) {
    mSearchKeySet.add("text");
    mSearchKeySet.add("content-desc");
    ConstantsUtils.document = null;//  w  w w.  ja  v a 2s  .co m
    UiHierarchyXmlLoader loader = new UiHierarchyXmlLoader();
    ConstantsUtils.document = loader.getDocument(xmlDumpFile.getAbsolutePath());
    List<Element> list = ConstantsUtils.document.selectNodes("//node");
    for (int i = 0; i < list.size(); i++) {
        Element e = list.get(i);
        e.setName(e.attributeValue("class"));
    }
    BasicTreeNode rootNode = loader.parseXml(xmlDumpFile.getAbsolutePath());
    if (rootNode == null) {
        System.err.println("null rootnode after parsing.");
        throw new IllegalArgumentException("Invalid ui automator hierarchy file.");
    }

    mNafNodes = loader.getNafNodes();
    if (mRootNode != null) {
        mRootNode.clearAllChildren();
    }

    mRootNode = rootNode;
    //        mExploreMode = true;
    mNodelist = loader.getAllNodes();
}

From source file:com.dockingsoftware.dockingpreference.NodeInfo.java

License:Apache License

/**
 * Constructor./*from www .jav  a2  s  . co m*/
 * 
 * @param element 
 */
public NodeInfo(Element element) {
    this.element = element;
    this.name = element.getName();
    this.clazz = element.attributeValue(GlobalConstant.CLASS);
    this.adapter = element.attributeValue(GlobalConstant.ADAPTER);
    this.value = element.getText().trim();// field value
    this.arrayType = element.attributeValue(GlobalConstant.ARRAY_TYPE);
    this.arrayLength = element.attributeValue(GlobalConstant.ARRAY_LENGTH);
}

From source file:com.doculibre.constellio.izpack.PersistenceXMLUtils.java

License:Open Source License

@SuppressWarnings("unchecked")
public static void run(AbstractUIProcessHandler handler, String[] args) {
    if (args.length != 5) {
        System.out.println("persistence_mysqlPath defaultPersistencePath server login password");
        return;/* w  ww.jav  a  2s  .  c om*/
    }

    String persistence_mysqlPath = args[0];
    String defaultPersistencePath = args[1];
    String server = args[2];
    String login = args[3];
    String password = args[4];

    Document xmlDocument;
    try {
        xmlDocument = new SAXReader().read(persistence_mysqlPath);
        Element root = xmlDocument.getRootElement();
        Iterator<Element> it = root.elementIterator("persistence-unit");
        if (!it.hasNext()) {
            System.out.println("Corrupt persistence file :" + persistence_mysqlPath);
            return;
        }
        it = it.next().elementIterator("properties");
        if (!it.hasNext()) {
            System.out.println("Corrupt persistence file :" + persistence_mysqlPath);
            return;
        }
        Element properties = it.next();
        for (it = properties.elementIterator("property"); it.hasNext();) {
            Element property = it.next();
            String id = property.attributeValue("name");
            if (id.equals(SERVER_ELEMENT_ID)) {
                Attribute att = property.attribute("value");
                att.setText(BEFORE_SERVER_NAME + server + AFTER_SERVER_NAME);
            } else {
                if (id.equals(LOGIN_ELEMENT_ID)) {
                    Attribute att = property.attribute("value");
                    att.setText(login);
                } else {
                    if (id.equals(PASSWORD_ELEMENT_ID)) {
                        Attribute att = property.attribute("value");
                        att.setText(password);
                    }
                }
            }

        }

        OutputFormat format = OutputFormat.createPrettyPrint();

        File xmlFile = new File(persistence_mysqlPath);
        XMLWriter writer2 = new XMLWriter(new FileOutputStream(xmlFile), format);

        writer2.write(xmlDocument);
        writer2.close();
        // copier au fichier de persistence par dfaut:
        xmlFile = new File(defaultPersistencePath);
        writer2 = new XMLWriter(new FileOutputStream(xmlFile), format);

        writer2.write(xmlDocument);
        writer2.close();

    } catch (DocumentException e) {
        e.printStackTrace();
    } catch (UnsupportedEncodingException e) {
        e.printStackTrace();
    } catch (FileNotFoundException e) {
        e.printStackTrace();
    } catch (IOException e) {
        e.printStackTrace();
    }

}

From source file:com.doculibre.constellio.izpack.TomcatUtil.java

License:Open Source License

@SuppressWarnings("unchecked")
public static void run(AbstractUIProcessHandler handler, String[] args) {
    if (args.length != 2) {
        System.out.println("serverPath port");
        return;//w w  w . j  a  v  a  2  s. c o m
    }

    String serverPath = args[0];
    String port = args[1];
    if (port.equals("8080")) {
        // C'est celui par defaut => ne rien faire
        return;
    }

    Document xmlDocument;
    try {
        xmlDocument = new SAXReader().read(serverPath);
        Element root = xmlDocument.getRootElement();

        Iterator<Element> it = root.elementIterator("Service");
        if (!it.hasNext()) {
            System.out.println("Corrupt persistence file :" + serverPath);
            return;
        }
        Element connectors = it.next();
        for (it = connectors.elementIterator("Connector"); it.hasNext();) {
            Element connector = it.next();
            String id = connector.attributeValue("protocol");
            if (id.startsWith("HTTP")) {
                Attribute att = connector.attribute("port");
                att.setText(port);
                break;
            }
        }

        OutputFormat format = OutputFormat.createPrettyPrint();

        File xmlFile = new File(serverPath);
        XMLWriter writer2 = new XMLWriter(new FileOutputStream(xmlFile), format);

        writer2.write(xmlDocument);
        writer2.close();
    } catch (DocumentException e) {
        e.printStackTrace();
    } catch (UnsupportedEncodingException e) {
        e.printStackTrace();
    } catch (FileNotFoundException e) {
        e.printStackTrace();
    } catch (IOException e) {
        e.printStackTrace();
    }

}

From source file:com.doculibre.constellio.services.ConnectorManagerServicesImpl.java

License:Open Source License

@SuppressWarnings("unchecked")
@Override//from   w w  w  .  ja v a2s  . c om
public Map<String, String> getConfig(ConnectorManager connectorManager, String connectorName) {
    Map<String, String> connectorConfigMap = new HashMap<String, String>();
    Map<String, String> paramsMap = new HashMap<String, String>();
    paramsMap.put(ServletUtil.XMLTAG_CONNECTOR_NAME, connectorName);
    Element xml = ConnectorManagerRequestUtils.sendGet(connectorManager, "/getConnectorConfig", paramsMap);
    List<Element> connectorConfigElements = xml.element(ServletUtil.XMLTAG_CONFIGURE_RESPONSE)
            .elements(ServletUtil.XMLTAG_PARAMETERS);
    for (Element connectorConfigElement : connectorConfigElements) {
        String name = connectorConfigElement.attributeValue("name");
        String value = connectorConfigElement.attributeValue("value");
        connectorConfigMap.put(name, value);
    }
    return connectorConfigMap;
}

From source file:com.doculibre.constellio.services.ElevateServicesImpl.java

License:Open Source License

@SuppressWarnings("unchecked")
private synchronized void readCache(String collectionName) {
    Map<String, List<String>> solrCoreElevationCache = elevationCache.get(collectionName);
    if (solrCoreElevationCache == null) {
        solrCoreElevationCache = new HashMap<String, List<String>>();
        elevationCache.put(collectionName, solrCoreElevationCache);

        Map<String, List<String>> solrCoreExclusionCache = new HashMap<String, List<String>>();
        exclusionCache.put(collectionName, solrCoreExclusionCache);

        Document document = SolrServicesImpl.readXMLConfigInCloud(collectionName, "elevate.xml");

        Element rootElement = document.getRootElement();
        for (Element queryElement : (List<Element>) rootElement.elements("query")) {
            String queryText = queryElement.attributeValue("text");
            String queryDisplayText = queryElement.attributeValue("displayText");
            if (queryDisplayText != null && displayQueriesCache.get(queryText) == null) {
                displayQueriesCache.put(queryText, queryDisplayText);
            }/*from w  w w . ja va2s  .  c o  m*/

            List<String> elevatedDocIds = new ArrayList<String>();
            List<String> excludedDocIds = new ArrayList<String>();

            for (Element docElement : (List<Element>) queryElement.elements("doc")) {
                String docId = docElement.attributeValue("id");
                if ("true".equals(docElement.attributeValue("exclude"))) {
                    excludedDocIds.add(docId);
                } else {
                    elevatedDocIds.add(docId);
                }
            }
            if (!elevatedDocIds.isEmpty()) {
                solrCoreElevationCache.put(queryText, elevatedDocIds);
            }
            if (!excludedDocIds.isEmpty()) {
                solrCoreExclusionCache.put(queryText, excludedDocIds);
            }
        }
    }
}

From source file:com.doculibre.constellio.services.ElevateServicesImpl.java

License:Open Source License

@SuppressWarnings("unchecked")
private synchronized void replaceQueryElement(String queryText, Element newQueryElement,
        String collectionName) {/*from   w w  w .j  a  v  a2s.  co  m*/
    Document document = SolrServicesImpl.readXMLConfigInCloud(collectionName, "elevate.xml");
    Element rootElement = document.getRootElement();
    int beanNodeIndex = -1;
    int i = 0;
    for (Node rootContent : (List<Node>) rootElement.content()) {
        if (rootContent instanceof Element) {
            Element possibleBeanElement = (Element) rootContent;
            if (queryText.equals(possibleBeanElement.attributeValue("text"))) {
                beanNodeIndex = i;
                break;
            }
        }
        i++;
    }

    if (beanNodeIndex != -1) {
        if (newQueryElement != null) {
            rootElement.content().set(beanNodeIndex, newQueryElement);
        } else {
            rootElement.content().remove(beanNodeIndex);
        }
    } else if (newQueryElement != null) {
        rootElement.add(newQueryElement);
    }

    // lets write to a file
    SolrServicesImpl.writeXMLConfigInCloud(collectionName, "elevate.xml", document);
}

From source file:com.doculibre.constellio.services.SolrServicesImpl.java

License:Open Source License

@SuppressWarnings("rawtypes")
private static void setProperty(Element element, String attributeName, ConstellioEntity entity) {
    try {/*from w w w.  j av a2 s.c o m*/
        Method getter = findGetter(entity.getClass(), attributeName);
        Class returnType = getter.getReturnType();
        String setterName = "set" + StringUtils.capitalize(attributeName);
        Method setter = entity.getClass().getMethod(setterName, returnType);

        String attributeValue = element.attributeValue(attributeName);
        Object setterValue;
        if (StringUtils.isEmpty(attributeValue)) {
            if (boolean.class.equals(returnType)) {
                setterValue = false;
            } else if (int.class.equals(returnType)) {
                setterValue = 0;
            } else if (returnType.isPrimitive()) {
                throw new UnsupportedOperationException(setterName + "(" + returnType + ")");
            } else {
                setterValue = null;
            }
        } else if (boolean.class.equals(returnType) || Boolean.class.equals(returnType)) {
            setterValue = Boolean.valueOf(attributeValue);
        } else if (int.class.equals(returnType) || Integer.class.equals(returnType)) {
            setterValue = Integer.valueOf(attributeValue);
        } else if (String.class.equals(returnType)) {
            setterValue = attributeValue;
        } else {
            throw new UnsupportedOperationException(setterName + "(" + returnType + ")");
        }
        setter.invoke(entity, setterValue);
    } catch (SecurityException e) {
        throw new RuntimeException(e);
    } catch (NoSuchMethodException e) {
        throw new RuntimeException(e);
    } catch (IllegalArgumentException e) {
        throw new RuntimeException(e);
    } catch (IllegalAccessException e) {
        throw new RuntimeException(e);
    } catch (InvocationTargetException e) {
        throw new RuntimeException(e);
    }
}

From source file:com.doculibre.constellio.services.SolrServicesImpl.java

License:Open Source License

@SuppressWarnings("unchecked")
@Override/* ww  w.j  a  v  a2  s  .  c  o  m*/
public synchronized void initConnectorTypeFields() {
    ConnectorTypeServices connectorTypeServices = ConstellioSpringUtils.getConnectorTypeServices();
    FieldTypeServices fieldTypeServices = ConstellioSpringUtils.getFieldTypeServices();
    AnalyzerClassServices analyzerClassServices = ConstellioSpringUtils.getAnalyzerClassServices();

    for (ConnectorType connectorType : connectorTypeServices.list()) {
        Collection<ConnectorTypeMetaMapping> connectorTypeMetaMappings = connectorType.getMetaMappings();
        if (connectorTypeMetaMappings.isEmpty()) {
            File connectorsDir = ConstellioSpringUtils.getGoogleConnectorsDir();
            File connectorTypeDir = new File(connectorsDir, connectorType.getName());
            File schemaFile = new File(connectorTypeDir, "schema.xml");

            // // we must ensure that collection with the name of
            // connectorType
            // // exists in solrcloud
            // Document schemaDocument =
            // readSchema(connectorType.getName());
            if (schemaFile.exists()) {
                Document schemaDocument = readSchema(schemaFile);
                if (schemaDocument != null) {
                    String defaultUniqueKeyName = "id";
                    String uniqueKeyFieldName = defaultUniqueKeyName;
                    Element uniqueKeyElement = schemaDocument.getRootElement().element("uniqueKey");
                    if (uniqueKeyElement != null) {
                        uniqueKeyFieldName = uniqueKeyElement.getText();
                    }

                    String defaultSearchFieldName;
                    Element defaultSearchFieldElement = schemaDocument.getRootElement()
                            .element("defaultSearchField");
                    if (defaultSearchFieldElement != null) {
                        defaultSearchFieldName = defaultSearchFieldElement.getText();
                    } else {
                        defaultSearchFieldName = null;
                    }

                    Element fieldsElement = schemaDocument.getRootElement().element("fields");
                    List<Element> fieldElements = fieldsElement.elements("field");
                    for (Iterator<Element> it = fieldElements.iterator(); it.hasNext();) {
                        Element fieldElement = it.next();

                        ConnectorTypeMetaMapping connectorTypeMetaMapping = new ConnectorTypeMetaMapping();
                        connectorType.addMetaMapping(connectorTypeMetaMapping);

                        String metaName = fieldElement.attributeValue("name");
                        connectorTypeMetaMapping.setMetaName(metaName);
                        if (metaName.equals(uniqueKeyFieldName)) {
                            connectorTypeMetaMapping.setUniqueKey(true);
                        }

                        if (defaultSearchFieldName != null && metaName.equals(defaultSearchFieldName)) {
                            connectorTypeMetaMapping.setDefaultSearchField(true);
                        }

                        String indexFieldName = IndexField.normalize(metaName);
                        connectorTypeMetaMapping.setIndexFieldName(indexFieldName);

                        setProperty(fieldElement, "indexed", connectorTypeMetaMapping);
                        // Defaults to true
                        // setProperty(fieldElement, "stored",
                        // connectorTypeMetaMapping);
                        setProperty(fieldElement, "multiValued", connectorTypeMetaMapping);

                        String analyzerClassName = fieldElement.attributeValue("analyzer");
                        if (analyzerClassName != null) {
                            AnalyzerClass analyzerClass = analyzerClassServices.get(analyzerClassName);
                            if (analyzerClass == null) {
                                analyzerClass = new AnalyzerClass();
                                analyzerClass.setClassName(analyzerClassName);
                                analyzerClassServices.makePersistent(analyzerClass, false);
                            }
                            Analyzer analyzer = new Analyzer();
                            analyzer.setAnalyzerClass(analyzerClass);
                            connectorTypeMetaMapping.setAnalyzer(analyzer);
                        }

                        String typeName = fieldElement.attributeValue("type");
                        FieldType fieldType = fieldTypeServices.get(typeName);
                        if (fieldType != null) {
                            connectorTypeMetaMapping.setFieldType(fieldType);
                            if (fieldType.getIndexed() != null) {
                                connectorTypeMetaMapping.setIndexed(fieldType.getIndexed());
                            }
                            if (fieldType.getMultiValued() != null) {
                                connectorTypeMetaMapping.setMultiValued(fieldType.getMultiValued());
                            }
                        }
                    }
                }
            }
        }
    }
}

From source file:com.doculibre.constellio.services.SolrServicesImpl.java

License:Open Source License

@Override
@SuppressWarnings("unchecked")
public Boolean createMissingFieldTypes(Document schemaDocument) {
    Boolean newFielTypes = false;
    FieldTypeServices fieldTypeServices = ConstellioSpringUtils.getFieldTypeServices();
    ConnectorManagerServices connectorManagerServices = ConstellioSpringUtils.getConnectorManagerServices();
    FieldTypeClassServices fieldTypeClassServices = ConstellioSpringUtils.getFieldTypeClassServices();
    FilterClassServices filterClassServices = ConstellioSpringUtils.getFilterClassServices();
    TokenizerClassServices tokenizerClassServices = ConstellioSpringUtils.getTokenizerClassServices();
    AnalyzerClassServices analyzerClassServices = ConstellioSpringUtils.getAnalyzerClassServices();

    ConnectorManager connectorManager = connectorManagerServices.getDefaultConnectorManager();

    Element typesElement = schemaDocument.getRootElement().element("types");
    if (typesElement != null) {
        List<Element> fieldTypeElements = typesElement.elements("fieldType");
        for (Element fieldTypeElement : fieldTypeElements) {
            String name = fieldTypeElement.attributeValue("name");
            FieldType fieldType = fieldTypeServices.get(name);
            if (fieldType == null) {
                newFielTypes = true;// w  w w.jav a2s .com
                fieldType = new FieldType();
                fieldType.setName(name);

                String fieldTypeClassName = fieldTypeElement.attributeValue("class");
                FieldTypeClass fieldTypeClass = fieldTypeClassServices.get(fieldTypeClassName);
                if (fieldTypeClass == null) {
                    fieldTypeClass = new FieldTypeClass();
                    fieldTypeClass.setClassName(fieldTypeClassName);
                    fieldTypeClass.setConnectorManager(connectorManager);
                    fieldTypeClassServices.makePersistent(fieldTypeClass);
                }
                fieldType.setFieldTypeClass(fieldTypeClass);
                fieldType.setConnectorManager(connectorManager);

                setProperty(fieldTypeElement, "indexed", fieldType);
                // Always true
                // setProperty(fieldTypeElement, "stored", fieldType);
                setProperty(fieldTypeElement, "multiValued", fieldType);
                setProperty(fieldTypeElement, "omitNorms", fieldType);
                setProperty(fieldTypeElement, "precisionStep", fieldType);
                setProperty(fieldTypeElement, "positionIncrementGap", fieldType);
                setProperty(fieldTypeElement, "sortMissingLast", fieldType);

                List<Element> analyzerElements = fieldTypeElement.elements("analyzer");
                Element analyzerElement = null;
                Element queryAnalyzerElement = null;
                for (Element element : analyzerElements) {
                    String type = element.attributeValue("type");
                    if (type == null || type.equals("index")) {
                        analyzerElement = element;
                    } else if (type.equals("query")) {
                        queryAnalyzerElement = element;
                    }
                }

                if (analyzerElement != null) {
                    Analyzer analyzer = new Analyzer();
                    fieldType.setAnalyzer(analyzer);

                    String analyzerClassName = analyzerElement.attributeValue("class");
                    if (analyzerClassName != null) {
                        AnalyzerClass analyzerClass = analyzerClassServices.get(analyzerClassName);
                        if (analyzerClass == null) {
                            analyzerClass = new AnalyzerClass();
                            analyzerClass.setClassName(analyzerClassName);
                            analyzerClass.setConnectorManager(connectorManager);
                            analyzerClassServices.makePersistent(analyzerClass, false);
                        }
                        analyzer.setAnalyzerClass(analyzerClass);
                    }

                    Element tokenizerElement = analyzerElement.element("tokenizer");
                    if (tokenizerElement != null) {
                        String tokenizerClassName = tokenizerElement.attributeValue("class");
                        TokenizerClass tokenizerClass = tokenizerClassServices.get(tokenizerClassName);
                        if (tokenizerClass == null) {
                            tokenizerClass = new TokenizerClass();
                            tokenizerClass.setClassName(tokenizerClassName);
                            tokenizerClass.setConnectorManager(connectorManager);
                            tokenizerClassServices.makePersistent(tokenizerClass, false);
                        }
                        analyzer.setTokenizerClass(tokenizerClass);
                    }

                    for (Element filterElement : (List<Element>) analyzerElement.elements("filter")) {
                        AnalyzerFilter filter = new AnalyzerFilter();
                        filter.setAnalyzer(analyzer);
                        analyzer.getFilters().add(filter);

                        String filterClassName = filterElement.attributeValue("class");
                        FilterClass filterClass = filterClassServices.get(filterClassName);
                        if (filterClass == null) {
                            filterClass = new FilterClass();
                            filterClass.setClassName(filterClassName);
                            filterClass.setConnectorManager(connectorManager);
                            filterClassServices.makePersistent(filterClass);
                        }
                        filter.setFilterClass(filterClass);

                        setProperty(filterElement, "catenateAll", filter);
                        setProperty(filterElement, "catenateWords", filter);
                        setProperty(filterElement, "delimiter", filter);
                        setProperty(filterElement, "enablePositionIncrements", filter);
                        setProperty(filterElement, "encoder", filter);
                        setProperty(filterElement, "expand", filter);
                        setProperty(filterElement, "generateNumberParts", filter);
                        setProperty(filterElement, "generateWordParts", filter);
                        setProperty(filterElement, "ignoreCase", filter);
                        setProperty(filterElement, "inject", filter);
                        setProperty(filterElement, "language", filter);
                        setProperty(filterElement, "pattern", filter);
                        if (filterElement.attribute("protected") != null) {
                            filter.setProtectedText(filterElement.attributeValue("protected"));
                        }
                        setProperty(filterElement, "replace", filter);
                        setProperty(filterElement, "replacement", filter);
                        setProperty(filterElement, "splitOnCaseChange", filter);
                        if (filterElement.attribute("synonyms") != null) {
                            filter.setSynonymsText(filterElement.attributeValue("synonyms"));
                        }
                        if (filterElement.attribute("words") != null) {
                            filter.setWordsText(filterElement.attributeValue("words"));
                        }
                    }
                }

                if (queryAnalyzerElement != null) {
                    Analyzer queryAnalyzer = new Analyzer();
                    fieldType.setQueryAnalyzer(queryAnalyzer);

                    String analyzerClassName = queryAnalyzerElement.attributeValue("class");
                    if (analyzerClassName != null) {
                        AnalyzerClass analyzerClass = analyzerClassServices.get(analyzerClassName);
                        if (analyzerClass == null) {
                            analyzerClass = new AnalyzerClass();
                            analyzerClass.setClassName(analyzerClassName);
                            analyzerClass.setConnectorManager(connectorManager);
                            analyzerClassServices.makePersistent(analyzerClass, false);
                        }
                        queryAnalyzer.setAnalyzerClass(analyzerClass);
                    }

                    Element tokenizerElement = queryAnalyzerElement.element("tokenizer");
                    if (tokenizerElement != null) {
                        String tokenizerClassName = tokenizerElement.attributeValue("class");
                        TokenizerClass tokenizerClass = tokenizerClassServices.get(tokenizerClassName);
                        if (tokenizerClass == null) {
                            tokenizerClass = new TokenizerClass();
                            tokenizerClass.setClassName(tokenizerClassName);
                            tokenizerClass.setConnectorManager(connectorManager);
                            tokenizerClassServices.makePersistent(tokenizerClass, false);
                        }
                        queryAnalyzer.setTokenizerClass(tokenizerClass);
                    }

                    for (Element filterElement : (List<Element>) queryAnalyzerElement.elements("filter")) {
                        AnalyzerFilter filter = new AnalyzerFilter();
                        filter.setAnalyzer(queryAnalyzer);
                        queryAnalyzer.getFilters().add(filter);

                        String filterClassName = filterElement.attributeValue("class");
                        FilterClass filterClass = filterClassServices.get(filterClassName);
                        if (filterClass == null) {
                            filterClass = new FilterClass();
                            filterClass.setClassName(filterClassName);
                            filterClass.setConnectorManager(connectorManager);
                            filterClassServices.makePersistent(filterClass);
                        }
                        filter.setFilterClass(filterClass);

                        setProperty(filterElement, "catenateAll", filter);
                        setProperty(filterElement, "catenateWords", filter);
                        setProperty(filterElement, "delimiter", filter);
                        setProperty(filterElement, "enablePositionIncrements", filter);
                        setProperty(filterElement, "encoder", filter);
                        setProperty(filterElement, "expand", filter);
                        setProperty(filterElement, "generateNumberParts", filter);
                        setProperty(filterElement, "generateWordParts", filter);
                        setProperty(filterElement, "ignoreCase", filter);
                        setProperty(filterElement, "inject", filter);
                        setProperty(filterElement, "language", filter);
                        setProperty(filterElement, "pattern", filter);
                        if (filterElement.attribute("protected") != null) {
                            filter.setProtectedText(filterElement.attributeValue("protected"));
                        }
                        setProperty(filterElement, "replace", filter);
                        setProperty(filterElement, "replacement", filter);
                        setProperty(filterElement, "splitOnCaseChange", filter);
                        if (filterElement.attribute("synonyms") != null) {
                            filter.setSynonymsText(filterElement.attributeValue("synonyms"));
                        }
                        if (filterElement.attribute("words") != null) {
                            filter.setWordsText(filterElement.attributeValue("words"));
                        }
                    }
                }

                fieldTypeServices.makePersistent(fieldType);
            }
        }
    }
    return newFielTypes;
}