Java PlexusConfiguration.getChildCount方法代码示例

import org.codehaus.plexus.configuration.PlexusConfiguration; //导入方法依赖的package包/类
private void write(PlexusConfiguration c, XMLWriter w, int depth) throws IOException {
  int count = c.getChildCount();

  if (count == 0) {
    writeTag(c, w, depth);
  } else {
    w.startElement(c.getName());
    writeAttributes(c, w);

    for (int i = 0; i < count; i++) {
      PlexusConfiguration child = c.getChild(i);

      write(child, w, depth + 1);
    }

    w.endElement();
  }
}
 

import org.codehaus.plexus.configuration.PlexusConfiguration; //导入方法依赖的package包/类
static void toIndentedString(PlexusConfiguration xml, int indentationSize, int currentDepth, Writer wrt)
        throws IOException {

    indent(indentationSize, currentDepth, wrt);

    boolean hasChildren = xml.getChildCount() > 0;
    boolean hasContent = xml.getValue() != null && !xml.getValue().isEmpty();
    wrt.write('<');
    wrt.write(xml.getName());
    if (!hasChildren && !hasContent) {
        wrt.write("/>");
    } else {
        wrt.write('>');
        if (hasChildren) {
            wrt.write('\n');
            for (PlexusConfiguration c : xml.getChildren()) {
                toIndentedString(c, indentationSize, currentDepth + 1, wrt);
                wrt.append('\n');
            }

            if (!hasContent) {
                indent(indentationSize, currentDepth, wrt);
            }
        }

        if (hasContent) {
            wrt.write(xml.getValue());
        }

        wrt.write("</");
        wrt.write(xml.getName());
        wrt.write('>');
    }
}
 

import org.codehaus.plexus.configuration.PlexusConfiguration; //导入方法依赖的package包/类
private void validateParameters( MojoDescriptor mojoDescriptor, PlexusConfiguration configuration,
                                 ExpressionEvaluator expressionEvaluator )
    throws ComponentConfigurationException, PluginParameterException
{
    if ( mojoDescriptor.getParameters() == null )
    {
        return;
    }

    List<Parameter> invalidParameters = new ArrayList<Parameter>();

    for ( Parameter parameter : mojoDescriptor.getParameters() )
    {
        if ( !parameter.isRequired() )
        {
            continue;
        }

        Object value = null;

        PlexusConfiguration config = configuration.getChild( parameter.getName(), false );
        if ( config != null )
        {
            String expression = config.getValue( null );

            try
            {
                value = expressionEvaluator.evaluate( expression );

                if ( value == null )
                {
                    value = config.getAttribute( "default-value", null );
                }
            }
            catch ( ExpressionEvaluationException e )
            {
                String msg =
                    "Error evaluating the expression '" + expression + "' for configuration value '"
                        + configuration.getName() + "'";
                throw new ComponentConfigurationException( configuration, msg, e );
            }
        }

        if ( value == null && ( config == null || config.getChildCount() <= 0 ) )
        {
            invalidParameters.add( parameter );
        }
    }

    if ( !invalidParameters.isEmpty() )
    {
        throw new PluginParameterException( mojoDescriptor, invalidParameters );
    }
}
 

import org.codehaus.plexus.configuration.PlexusConfiguration; //导入方法依赖的package包/类
public void processConfiguration(final ConverterLookup converterLookup,
		final Object object, final ClassLoader classLoader,
		final PlexusConfiguration configuration,
		final ExpressionEvaluator expressionEvaluator,
		final ConfigurationListener listener)
		throws ComponentConfigurationException {
	final int items = configuration.getChildCount();

	for (int i = 0; i < items; i++) {
		final PlexusConfiguration childConfiguration = configuration
				.getChild(i);

		final String elementName = childConfiguration.getName();

		Class<?> implementation;
		try {
			implementation = getClassForImplementationHint(null,
					childConfiguration, classLoader);
		} catch (final Exception e) {
			implementation = null; // fall back to original behavior
		}

		final ComponentValueSetter valueSetter = new ComponentValueSetter(
				fromXML(elementName), implementation, object,
				converterLookup, listener);

		valueSetter.configure(childConfiguration, classLoader,
				expressionEvaluator);
	}

	Class<?> mojoClass = object.getClass();

	while (mojoClass != Object.class) {
		Field[] declaredFields = mojoClass.getDeclaredFields();
		List<PropertyEditorField> editorSupportFields = new ArrayList<PropertyEditorField>();
		for (Field declaredField : declaredFields) {
			if (declaredField.isAnnotationPresent(PropertyEditor.class)) {
				PropertyEditorField propertyEditorField = new PropertyEditorField(
						object, declaredField);
				editorSupportFields.add(propertyEditorField);
			}
		}

		handlePropertyEditorFields(object, editorSupportFields,
				expressionEvaluator);
		mojoClass = mojoClass.getSuperclass();
	}
}