* limitations under the License.
 */

package org.gradle.model.internal.core;

import org.gradle.api.specs.Spec;
import org.gradle.model.internal.type.ModelType;

public interface ChildNodeInitializerStrategy<T> {

    // Node must project item as S
    <S extends T> NodeInitializer initializer(ModelType<S> type, Spec<ModelType<?>> constraints);

    private static final ModelType<ChildNodeInitializerStrategy<?>> CHILD_NODE_INITIALIZER_STRATEGY_MODEL_TYPE =
        Cast.uncheckedCast(ModelType.of(ChildNodeInitializerStrategy.class));

    public static <T> ChildNodeInitializerStrategyAccessor<T> fromPrivateData() {
        return new ChildNodeInitializerStrategyAccessor<T>() {
            @Override
            public ChildNodeInitializerStrategy<T> getStrategy(MutableModelNode node) {

            DefaultModelViewState state = new DefaultModelViewState(modelNode.getPath(), setType, ruleDescriptor, mutable, !mutable);
            ChildNodeInitializerStrategy<T> childStrategy = Cast.uncheckedCast(modelNode.getPrivateData(ChildNodeInitializerStrategy.class));
            NodeBackedModelSet<T> set = new NodeBackedModelSet<T>(setType, elementType, ruleDescriptor, modelNode, state, childStrategy);

        return new ChildNodeInitializerStrategy<T>() {
            @Override
            public <S extends T> NodeInitializer initializer(ModelType<S> type, Spec<ModelType<?>> constraints) {
                return nodeInitializerRegistry.getNodeInitializer(forExtensibleType(type, constraints));
            }
        };
    }

    private static final ModelType<ChildNodeInitializerStrategy<?>> CHILD_NODE_INITIALIZER_STRATEGY_MODEL_TYPE =
        Cast.uncheckedCast(ModelType.of(ChildNodeInitializerStrategy.class));

    public static <T> MutableModelNode addModelMapNode(MutableModelNode modelNode, ModelType<T> elementModelType, String name) {

import org.gradle.model.internal.core.ChildNodeInitializerStrategy;
import org.gradle.model.internal.core.NodeInitializer;
import org.gradle.model.internal.core.NodeInitializerRegistry;
import org.gradle.model.internal.type.ModelType;

import static org.gradle.model.internal.core.NodeInitializerContext.forType;

public class ManagedChildNodeCreatorStrategy<T> implements ChildNodeInitializerStrategy<T> {

                    public void execute(MutableModelNode modelNode, NodeInitializerRegistry nodeInitializerRegistry) {
                        ChildNodeInitializerStrategy<E> childFactory = NodeBackedModelMap.createUsingRegistry(nodeInitializerRegistry);
                        modelNode.setPrivateData(ModelType.of(ChildNodeInitializerStrategy.class), childFactory);
                    }
                }
            ))
            .build();
    }

                            ChildNodeInitializerStrategy<E> childStrategy = NodeBackedModelMap.createUsingRegistry(nodeInitializerRegistry);
                            modelNode.setPrivateData(ChildNodeInitializerStrategy.class, childStrategy);
                        }
                    }
                ))
                .build();
        }

    private final ModelType<T> elementType;
    private final ModelRuleDescriptor descriptor;
    private final MutableModelNode modelNode;
    private final ModelViewState state;
    private final ChildNodeInitializerStrategy<T> creatorStrategy;
    private final ModelReference<T> elementTypeReference;
    private final ModelType<?> publicType;

    private Collection<T> elements;

 * limitations under the License.
 */

package org.gradle.model.internal.core;

public interface ChildNodeInitializerStrategyAccessor<T> {
    ChildNodeInitializerStrategy<T> getStrategy(MutableModelNode node);