@SerialName("configuringLambdaArgument")
    data class DefaultConfiguringLambdaArgument(override val objectType: DataTypeRef) : ConfigureAccessor.ConfiguringLambdaArgument

    // TODO: configure all elements by addition key?
    // TODO: Do we want to support configuring external objects?
}


@Serializable
data class DefaultFqName(override val packageName: String, override val simpleName: String) : FqName {

            }
            return map;
        }

        public void nodeRemoved(ModelNodeInternal node) {
            // This could be more efficient; assume that removal happens much less often than addition
            for (ModelNode.State state : ModelNode.State.values()) {
                Map<String, List<RuleBinder>> byState = getByState(state);
                List<RuleBinder> remove = byState.remove(node.getPath().toString());

    }

    /**
     * Returns the ClassLoader that contains the Java platform classes only. This is different to {@link ClassLoader#getSystemClassLoader()}, which includes the application classes in addition to the
     * platform classes.
     */
    public static ClassLoader getPlatformClassLoader() {
        return ClassLoader.getSystemClassLoader().getParent();
    }

Gradle manages this distinction via the <<cpp_library_plugin.adoc#cpp_library_plugin,{cpp} Library Plugin>>, which introduces an _api_ configuration in addition to the _implementation_ once covered in this chapter.

  let summary = "Replace quantization candidates with composite functions into the module.";
  let description = [{
    Mark frequent fusible patterns as functions for quantization targets.
    In addition to brining performance benefits by reducing q/dq op overhead in non-full quantization,
    this brings higher accuracy by keeping a smaller range when quantizing ops
    that disperse values. (ex: convolution, dot_general)
  }];

Gradle enforces isolation of instances of `ComponentMetadataRule`.
This means that all parameters must be `Serializable` or known Gradle types that can be isolated.

In addition, Gradle services can be injected into your `ComponentMetadataRule`.
Because of this, the moment you have a constructor, it must be annotated with `@javax.inject.Inject`.

            model.setDependencies(convertDependencies(dependencies));
        }

        XmlTransformer xmlTransformer = new XmlTransformer();
        xmlTransformer.addAction(pom.getXmlAction());
        if (pom.getWriteGradleMetadataMarker().get()) {
            xmlTransformer.addFinalizer(SerializableLambdas.action(MavenPomFileGenerator::insertGradleMetadataMarker));
        }

}

// add returns p+x.
//
// The whySafe string is ignored, so that the function still inlines
// as efficiently as p+x, but all call sites should use the string to
// record why the addition is safe, which is to say why the addition
// does not cause x to advance to the very end of p's allocation
// and therefore point incorrectly at the next block in memory.
func add(p unsafe.Pointer, x uintptr, whySafe string) unsafe.Pointer {

 * </p>
 *     <ul>
 *         <li>{@link SingleElement} to represent a single element addition
 *         <li>{@link ElementFromProvider} to represent a single element added as a provider
 *         <li>{@link ElementsFromArray} to represent a single element added as an array</li>

/**
 * Using simple dotted expressions to extract the values from an Object instance using JSP-like expressions
 * such as {@code project.build.sourceDirectory}.
 * <p>
 * In addition to usual getters using {@code getXxx} or {@code isXxx} suffixes, accessors
 * using {@code asXxx} or {@code toXxx} prefixes are also supported.
 */
public class ReflectionValueExtractor {