~~ KIND, either express or implied.  See the License for the
~~ specific language governing permissions and limitations
~~ under the License.

 -----
 Super POM
 -----
 Hervé Boutemy
 -----
 2011-09-12
 -----

Super POM

 All models implicitly inherit from a super-POM:

under the License.
-->

<model>
  <groupId>foo</groupId>
  <artifactId>bar</artifactId>
  <name>Babar</name>
  <version>4.5</version>

  <!-- Build element should be inherited from the super model -->

        super.setActions(replacements);
    }

    @Override
    public Set<Object> getDependsOn() {
        return super.getDependsOn();
    }

    @Override
    public void setDependsOn(Iterable<?> dependsOn) {
        super.setDependsOn(dependsOn);
    }

    @Override
    public void onlyIf(Spec<? super Task> spec) {
        super.onlyIf(spec);
    }

    @Override

        return action(ModelType.of(inputType), action);
    }

    private ModelAction build(List<ModelReference<?>> references, TriAction<? super MutableModelNode, ? super T, ? super List<ModelView<?>>> action) {
        return toAction(references, action, path, type, descriptor);
    }

        ImmutableSet.Builder<Action<? super T>> builder = ImmutableSet.builder();
        one.unpackInto(builder);
        two.unpackInto(builder);
        ImmutableSet<Action<? super T>> set = builder.build();
        return fromActions(set);
    }

    private static <T> ImmutableActionSet<T> plus(ImmutableActionSet<T> one, Action<? super T> two) {
        ImmutableSet.Builder<Action<? super T>> builder = ImmutableSet.builder();

        public <U, V> Either<U, V> mapLeft(Function<? super L, ? extends U> f) {
            return (Either<U, V>) this;
        }

        @Override
        public <U, V> Either<U, V> mapRight(Function<? super R, ? extends V> f) {
            return new Right<>(f.apply(value));
        }

        @Override
        public <U> U fold(Function<? super L, ? extends U> l, Function<? super R, ? extends U> r) {

        super(message);
        pluginKey = plugin.getKey();
    }

    public PluginLoaderException(String message) {
        super(message);
    }

    public PluginLoaderException(String message, Throwable cause) {
        super(message, cause);
    }

    public PluginLoaderException(ReportPlugin plugin, String message, Throwable cause) {
        super(message, cause);

                def "super super test"() $testBody
                def "super super unrolled test"() $unrolledTestBody
                def "super super unrolled test param=#param"() $unrolledTestBody
            }
        """
        file("src/test/groovy/SuperClass.groovy") << """
            abstract class SuperClass extends SuperSuperClass {
                def "super test"() $testBody

        this(collection, filter, instantiator, namer, MutationGuards.identity());
    }

    // should be protected, but use of the class generator forces it to be public

        if (specs.size() == 0) {
            return satisfyAll();
        }
        return doUnion(specs);
    }

    private static <T> Spec<T> doUnion(Collection<? extends Spec<? super T>> specs) {
        List<Spec<? super T>> filtered = new ArrayList<Spec<? super T>>(specs.size());
        for (Spec<? super T> spec : specs) {