Parameter which indicates an XML file containing AspectJ weaving instructions.
Assigning this plugin parameter adds the <code>-xmlConfigured</code> option to ajc.

@param xmlConfigured an XML file containing AspectJ weaving instructions.
4100
public void setXmlConfigured( final File xmlConfigured )
    {
        try
        {
            final String path = xmlConfigured.getCanonicalPath();
            if ( !xmlConfigured.exists() )
            {
                getLog().warn( "xmlConfigured parameter invalid. [" + path + "] does not exist." );
            }
            else if ( !path.trim().toLowerCase().endsWith( ".xml" ) )
            {
                getLog().warn( "xmlConfigured parameter invalid. XML file name must end in .xml" );
            }
            else
            {
                this.xmlConfigured = xmlConfigured;
            }
        }
        catch ( Exception e )
        {
            getLog().error( "Exception setting xmlConfigured option", e );
        }
    }
568963
private void readConfiguration(String fileName, IChemObjectBuilder builder) {
        logger.info("Reading config file from ", fileName);

        InputStream ins;
        {
            //try to see if this is a resource
            ins = this.getClass().getClassLoader().getResourceAsStream(fileName);
            if (ins == null) {
                // try to see if this configFile is an actual file
                File file = new File(fileName);
                if (file.exists()) {
                    logger.debug("configFile is a File");
                    // what's next?
                    try {
                        ins = new FileInputStream(file);
                    } catch (Exception exception) {
                        logger.error(exception.getMessage());
                        logger.debug(exception);
                    }
                } else {
                    logger.error("no stream and no file");
                }
            }
        }

        String format = XML_EXTENSION;
        if (fileName.endsWith(TXT_EXTENSION)) {
            format = TXT_EXTENSION;
        } else if (fileName.endsWith(XML_EXTENSION)) {
            format = XML_EXTENSION;
        } else if (fileName.endsWith(OWL_EXTENSION)) {
            format = OWL_EXTENSION;
        }
        readConfiguration(ins, format, builder);
    }
811018
@Override
    public void configureSelected(PMContext ctx) throws NumberFormatException, PMException {
        if (ctx.getEntityContainer().isSelectedNew()) {
            ctx.getEntityContainer().setSelected(null);
        } else {
            super.configureSelected(ctx);
        }
    }
121618
public void doRuntimeConfiguration(RuntimeSpringConfiguration springConfig) {
        ApplicationContext context = springConfig.getUnrefreshedApplicationContext();
        AutowireCapableBeanFactory autowireCapableBeanFactory = context.getAutowireCapableBeanFactory();
        if(autowireCapableBeanFactory instanceof ConfigurableListableBeanFactory) {
            ConfigurableListableBeanFactory beanFactory = (ConfigurableListableBeanFactory)autowireCapableBeanFactory;
            ConversionService existingConversionService = beanFactory.getConversionService();
            ConverterRegistry converterRegistry;
            if(existingConversionService == null) {
                GenericConversionService conversionService = new GenericConversionService();
                converterRegistry = conversionService;
                beanFactory.setConversionService(conversionService);
            }
            else {
                converterRegistry = (ConverterRegistry)existingConversionService;
            }

            converterRegistry.addConverter(new Converter<NavigableMap.NullSafeNavigator, Object>() {
                @Override
                public Object convert(NavigableMap.NullSafeNavigator source) {
                    return null;
                }
            });
        }
        checkInitialised();
        for (GrailsPlugin plugin : pluginList) {
            if (plugin.supportsCurrentScopeAndEnvironment() && plugin.isEnabled(context.getEnvironment().getActiveProfiles())) {
                plugin.doWithRuntimeConfiguration(springConfig);
            }
        }
    }
1317132
@Override
	public void configure(Configuration parameters) {

		if (getFilePaths().length == 0) {
			// file path was not specified yet. Try to set it from the parameters.
			String filePath = parameters.getString(FILE_PARAMETER_KEY, null);
			if (filePath == null) {
				throw new IllegalArgumentException("File path was not specified in input format or configuration.");
			} else {
				setFilePath(filePath);
			}
		}

		if (!this.enumerateNestedFiles) {
			this.enumerateNestedFiles = parameters.getBoolean(ENUMERATE_NESTED_FILES_FLAG, false);
		}
	}
927760
public void generateXml(Element parent, I_CmsConfigurationParameterHandler config) {

        if (config != null) {
            Element elem = parent.addElement(m_name);
            for (String attrName : m_attrs) {
                String value = config.getConfiguration().get(attrName);
                if (value != null) {
                    elem.addAttribute(attrName, value);
                }
            }
        }
    }
37904
protected void updatePluginConfiguration(PluginConfiguration value, String xmlTag, Counter counter,
            Element element)
   {
      boolean shouldExist = value != null;
      Element root = updateElement(counter, element, xmlTag, shouldExist);
      if (shouldExist)
      {
         Counter innerCount = new Counter(counter.getDepth() + 1);
         updatePluginManagement(value.getPluginManagement(), "pluginManagement", innerCount, root);
         iteratePlugin(innerCount, root, value.getPlugins(), "plugins", "plugin");
      }
   }
101168
public void configure(CompilerConfiguration configuration) {
        super.configure(configuration);
        this.debug = configuration.getDebug();

        if (!this.configured && this.classLoader instanceof GroovyClassLoader) {
            appendCompilerConfigurationClasspathToClassLoader(configuration, (GroovyClassLoader) this.classLoader);
        }

        this.configured = true;
    }
65904
public void setConfigure(java.util.Collection<String> configure) {
        if (configure == null) {
            this.configure = null;
            return;
        }

        this.configure = new com.amazonaws.internal.SdkInternalList<String>(configure);
    }
547607
private void configure(Object obj, XmlParser.Node cfg, int i) throws ClassNotFoundException,
            NoSuchMethodException, InvocationTargetException, IllegalAccessException
    {
        XmlParser.Node node = null;
        try
        {
            for (; i < cfg.size(); i++)
            {
                Object o = cfg.get(i);
                if (o instanceof String) continue;
                node = (XmlParser.Node) o;

                String tag = node.getTag();
                if ("Set".equals(tag))
                    set(obj, node);
                else if ("Put".equals(tag))
                    put(obj, node);
                else if ("Call".equals(tag))
                    call(obj, node);
                else if ("Get".equals(tag))
                    get(obj, node);
                else if ("New".equals(tag))
                    newObj(obj, node);
                else if ("Ref".equals(tag))
                    refObj(obj, node);
                else
                    throw new IllegalStateException("Unknown tag: " + tag);
            }
        }
        catch(InvocationTargetException e)
        {
            log.warn("Exception at "+node.toString(),e.getTargetException());
            throw e;
        }
        catch (Error e)
        {
            log.debug(node);
            throw e;
        }
        catch (Exception e)
        {
            log.debug(node);
            if (e instanceof NoSuchMethodException) throw (NoSuchMethodException) e;
            if (e instanceof InvocationTargetException) throw (InvocationTargetException) e;
            if (e instanceof IllegalAccessException) throw (IllegalAccessException) e;
            if (e instanceof RuntimeException) throw (RuntimeException) e;
        }
    }
737628
@Override
    public void processXML() throws InjectionException {

        final boolean isTraceOn = TraceComponent.isAnyTracingEnabled();
        if (isTraceOn && tc.isEntryEnabled())
            Tr.entry(tc, "processXML : " + this);

        List<? extends AdministeredObject> administeredObjectDefinitions = ivNameSpaceConfig.getJNDIEnvironmentRefs(AdministeredObject.class);

        if (administeredObjectDefinitions != null)
        {
            for (AdministeredObject administeredObject : administeredObjectDefinitions)
            {
                String jndiName = administeredObject.getName();
                InjectionBinding<AdministeredObjectDefinition> injectionBinding = ivAllAnnotationsCollection.get(jndiName);
                AdministeredObjectDefinitionInjectionBinding binding;

                if (injectionBinding != null)
                {
                    binding = (AdministeredObjectDefinitionInjectionBinding) injectionBinding;
                }
                else
                {
                    binding = new AdministeredObjectDefinitionInjectionBinding(jndiName, ivNameSpaceConfig);
                    addInjectionBinding(binding);
                }

                binding.mergeXML(administeredObject);
            }
        }

        if (isTraceOn && tc.isEntryEnabled())
            Tr.exit(tc, "processXML : " + this);

    }
678772
static void createConfigFile(String xmlName, Resource configFile) throws IOException {
	configFile.createFile(true);
	createFileFromResource("/resource/config/" + xmlName + ".xml", configFile.getAbsoluteResource());
    }
624072
private void configurePlugins(final File fDir) throws PluginConfigurationException {
        LOG.trace("READING PLUGIN CONFIGURATION FROM DIRECTORY {}", fDir.getName());
        StreamManager streamMgr = new StreamManager();

        File[] vfJars = fDir.listFiles(JAR_FILE_FILTER);

        if (vfJars == null || vfJars.length == 0) {
            return;
        }

        // Initializing classloader
        List<URL> vUrls = new ArrayList<URL>(vfJars.length);

        ClassLoader ul = null;

        for (int j = 0; j < vfJars.length; j++) {
            try {
                vUrls.add(vfJars[j].toURI().toURL());
            } catch (MalformedURLException e) {
                // should never happen
                throw new IllegalStateException(e.getMessage(), e);
            }
        }

        ul = new JNRPEClassLoader(vUrls);

        try {
            for (File file : vfJars) {
                JarFile jarFile = null;
                try {
                    jarFile = new JarFile(file);
                    JarEntry entry = jarFile.getJarEntry("plugin.xml");
                    if (entry == null) {
                        entry = jarFile.getJarEntry("jnrpe_plugins.xml");
                    }

                    if (entry == null) {
                        // The jar do not contain a jnrpe_plugins.xml nor a
                        // plugin.xml file...
                        continue;
                    }

                    InputStream in = streamMgr.handle(jarFile.getInputStream(entry));
                    PluginRepositoryUtil.loadFromXmlPluginPackageDefinitions(this, ul, in);
                    in.close();

                } catch (Exception e) {
                    LOG.error("Skipping plugin package contained in file '{}' because of the following error : {}",
                            new String[] { file.getName(), e.getMessage() }, e);
                } finally {
                    try {
                        jarFile.close();
                    } catch (Exception e) {
                        // Intentionally ignored...
                        LOG.warn("An error has occurred closing jar file '{}'",file.getName(), e);
                    }
                }
            }

        } finally {
            streamMgr.closeAll();
        }
    }
696140
public static synchronized void configure(final ApiConfiguration config) {
		
		ApiConfiguration.Builder builder = ApiConfiguration.newBuilder();
		
		builder.apiUrl(config.getApiUrl());
		builder.apiKey(config.getApiKey());
		builder.application(config.getApplication());
		builder.environment(config.getEnvironment());
		
		if (config.getEnvDetail() == null)
		{
			builder.envDetail(EnvironmentDetails.getEnvironmentDetail(config.getApplication(), config.getEnvironment()));
		}
		else
		{
			builder.envDetail(config.getEnvDetail());
		}
		
		CONFIG = builder.build();
	}
578681
private static boolean isMapped(Class<?> aClass,XML xml){
		return xml.isInheritedMapped(aClass) || Annotation.isInheritedMapped(aClass);
	}
1230544
protected void writeAnnotations( IAnnotated annotated)
    {
    toStream( annotated.getAnnotations())
      .sorted()
      .forEach( annotation -> {
        xmlWriter_
          .element( HAS_TAG)
          .attribute( NAME_ATR, annotation)
          .attribute( VALUE_ATR, annotated.getAnnotation( annotation))
          .write();
        });
    }
1314074
@Override
	public void configure(final LoggerContext loggerContext) {
		addInfo("Setting up custom configuration.");
		final LoggerContext context = (LoggerContext) StaticLoggerBinder.getSingleton().getLoggerFactory();
		final JoranConfigurator jc = new JoranConfigurator();
		jc.setContext(context);
		context.reset();
		context.putProperty("application-name", appName);
		openStream(jc);
	}