this.taskDependencyFactory = taskDependencyFactory;
        this.instantiator = instantiator;
        this.objectFactory = objectFactory;
    }

    @Override
    protected SourceSet doCreate(String name) {
        DefaultSourceSet sourceSet = instantiator.newInstance(DefaultSourceSet.class, name, objectFactory);

    }

    @Override
    public void content(Action<? super RepositoryContentDescriptor> configureAction) {
        throw new UnsupportedOperationException();
    }

    @Override
    protected PrebuiltLibrary doCreate(String name) {
        return getInstantiator().newInstance(DefaultPrebuiltLibrary.class, name, objectFactory, domainObjectCollectionFactory);
    }

    @Override
    public PrebuiltLibrary resolveLibrary(String name) {

        super(type, instantiator, callbackDecorator);
        this.objectFactory = objectFactory;
        this.fileOperations = fileOperations;
    }

    @Override
    protected Distribution doCreate(String name) {
        return objectFactory.newInstance(DefaultDistribution.class, name, fileOperations.copySpec());
    }

        boolean doIndexCreate = false;
        boolean doCreate = false;
        try {
            final GetResponse getResponse =
                    client.prepareGet().setIndex(settingsIndexName).setId(settingsId).execute().actionGet(getSearchTimeout());

            if (!getResponse.isExists()) {
                doCreate = true;
            }
        } catch (final IndexNotFoundException e) {

        super(ArtifactTypeDefinition.class, instantiator, callbackActionDecorator);
        this.attributesFactory = attributesFactory;
    }

    @Override
    protected ArtifactTypeDefinition doCreate(final String name) {
        return getInstantiator().newInstance(DefaultArtifactTypeDefinition.class, name, attributesFactory);
    }

    public static class DefaultArtifactTypeDefinition implements ArtifactTypeDefinition {

        return doCreate(type, displayName, parameters);
    }

    @Override
    public <T> T newInstance(Class<? extends T> type, Object... parameters) {
        return doCreate(type, null, parameters);
    }

    @Nonnull
    private <T> T doCreate(Class<? extends T> type, @Nullable Describable displayName, Object[] parameters) {
        try {

    }

    @Override
    public NamedEntityInstantiator<T> getEntityInstantiator() {
        return namedEntityInstantiator;
    }

    @Override
    protected T doCreate(String name) {
        try {
            return namedEntityInstantiator.create(name, getType());
        } catch (InvalidUserDataException e) {
            if (e.getCause() instanceof NoFactoryRegisteredForTypeException) {

        super(BuildType.class, instantiator, collectionCallbackActionDecorator);
    }

    @Override
    protected BuildType doCreate(String name) {
        return getInstantiator().newInstance(DefaultBuildType.class, name);
    }

        super(Flavor.class, instantiator, collectionCallbackActionDecorator);
    }

    @Override
    protected Flavor doCreate(String name) {
        return getInstantiator().newInstance(DefaultFlavor.class, name);
    }

     * the existing public API, they may be used in non-idiomatic ways that will make this difficult.
     * <p>
     * This test will ensure that calls into {@code DefaultConfgurationContainer#doCreate(String)} in non-test code
     * begin with a call from a method in {@code RoleBasedConfigurationContainerInternal}.
     * (The banned alternate {@code create} methods are defined in {@code ConfigurationContainer} and