org.apache.maven.model.building.Result Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of maven-model-builder Show documentation
Show all versions of maven-model-builder Show documentation
The effective model builder, with inheritance, profile activation, interpolation, ...
package org.apache.maven.model.building;
/*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied. See the License for the
* specific language governing permissions and limitations
* under the License.
*/
import static java.util.Collections.singleton;
import static org.apache.maven.model.building.ModelProblem.Severity.ERROR;
import static org.apache.maven.model.building.ModelProblem.Severity.FATAL;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.List;
/**
* There are various forms of results that are represented by this class:
*
* - success - in which case only the model field is set
*
- success with warnings - model field + non-error model problems
*
- error - no model, but diagnostics
*
- error - (partial) model and diagnostics
*
* Could encode these variants as subclasses, but kept in one for now
*
* @author bbusjaeger
* @param
*/
public class Result
{
/**
* Success without warnings
*
* @param model
*/
public static Result success( T model )
{
return success( model, Collections.emptyList() );
}
/**
* Success with warnings
*
* @param model
* @param problems
*/
public static Result success( T model, Iterable problems )
{
assert !hasErrors( problems );
return new Result<>( false, model, problems );
}
/**
* Success with warnings
*
* @param model
* @param results
*/
public static Result success( T model, Result... results )
{
final List problemsList = new ArrayList<>();
for ( Result result1 : results )
{
for ( ModelProblem modelProblem : result1.getProblems() )
{
problemsList.add( modelProblem );
}
}
return success( model, problemsList );
}
/**
* Error with problems describing the cause
*
* @param problems
*/
public static Result error( Iterable problems )
{
return error( null, problems );
}
public static Result error( T model )
{
return error( model, Collections.emptyList() );
}
public static Result error( Result result )
{
return error( result.getProblems() );
}
public static Result error( Result... results )
{
final List problemsList = new ArrayList<>( );
for ( Result result1 : results )
{
for ( ModelProblem modelProblem : result1.getProblems( ) )
{
problemsList.add( modelProblem );
}
}
return error( problemsList );
}
/**
* Error with partial result and problems describing the cause
*
* @param model
* @param problems
*/
public static Result error( T model, Iterable problems )
{
return new Result<>( true, model, problems );
}
/**
* New result - determine whether error or success by checking problems for errors
*
* @param model
* @param problems
*/
public static Result newResult( T model, Iterable problems )
{
return new Result<>( hasErrors( problems ), model, problems );
}
/**
* New result consisting of given result and new problem. Convenience for newResult(result.get(),
* concat(result.getProblems(),problems)).
*
* @param result
* @param problem
*/
public static Result addProblem( Result result, ModelProblem problem )
{
return addProblems( result, singleton( problem ) );
}
/**
* New result that includes the given
*
* @param result
* @param problems
*/
public static Result addProblems( Result result, Iterable problems )
{
Collection list = new ArrayList<>();
for ( ModelProblem item : problems )
{
list.add( item );
}
for ( ModelProblem item : result.getProblems() )
{
list.add( item );
}
return new Result<>( result.hasErrors() || hasErrors( problems ), result.get(), list );
}
public static Result addProblems( Result result, Result... results )
{
final List problemsList = new ArrayList<>();
for ( Result result1 : results )
{
for ( ModelProblem modelProblem : result1.getProblems( ) )
{
problemsList.add( modelProblem );
}
}
return addProblems( result, problemsList );
}
/**
* Turns the given results into a single result by combining problems and models into single collection.
*
* @param results
*/
public static Result> newResultSet( Iterable> results )
{
boolean hasErrors = false;
List modelsList = new ArrayList<>();
List problemsList = new ArrayList<>();
for ( Result result : results )
{
modelsList.add( result.get() );
for ( ModelProblem modelProblem : result.getProblems() )
{
problemsList.add( modelProblem );
}
if ( result.hasErrors() )
{
hasErrors = true;
}
}
return new Result<>( hasErrors, ( Iterable ) modelsList, problemsList );
}
// helper to determine if problems contain error
private static boolean hasErrors( Iterable problems )
{
for ( ModelProblem input : problems )
{
if ( input.getSeverity().equals( ERROR ) || input.getSeverity().equals( FATAL ) )
{
return true;
}
}
return false;
}
/**
* Class definition
*/
private final boolean errors;
private final T value;
private final Iterable problems;
private Result( boolean errors, T model, Iterable problems )
{
this.errors = errors;
this.value = model;
this.problems = problems;
}
public Iterable getProblems()
{
return problems;
}
public T get()
{
return value;
}
public boolean hasErrors()
{
return errors;
}
}