/*
    * Copyright 2012-2013 smartics, Kronseder & Reiner GmbH
    *
    * Licensed 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.
   */
  package de.smartics.maven.issue.util; // NOPMD
  
  import java.io.File;
  import java.io.IOException;
  import java.io.Writer;
  import java.util.List;
  import java.util.Map;
  import java.util.Properties;
  import java.util.Set;
  
  import org.apache.maven.artifact.Artifact;
  import org.apache.maven.artifact.DependencyResolutionRequiredException;
  import org.apache.maven.artifact.factory.ArtifactFactory;
  import org.apache.maven.artifact.repository.ArtifactRepository;
  import org.apache.maven.artifact.resolver.filter.ArtifactFilter;
  import org.apache.maven.model.Build;
  import org.apache.maven.model.CiManagement;
  import org.apache.maven.model.Contributor;
  import org.apache.maven.model.DependencyManagement;
  import org.apache.maven.model.Developer;
  import org.apache.maven.model.DistributionManagement;
  import org.apache.maven.model.IssueManagement;
  import org.apache.maven.model.License;
  import org.apache.maven.model.MailingList;
  import org.apache.maven.model.Model;
  import org.apache.maven.model.Organization;
  import org.apache.maven.model.Plugin;
  import org.apache.maven.model.PluginManagement;
  import org.apache.maven.model.Prerequisites;
  import org.apache.maven.model.Reporting;
  import org.apache.maven.model.Resource;
  import org.apache.maven.model.Scm;
  import org.apache.maven.project.MavenProject;
  import org.apache.maven.project.ProjectBuilderConfiguration;
  import org.apache.maven.project.artifact.InvalidDependencyVersionException;
  import org.codehaus.plexus.logging.Logger;
  import org.codehaus.plexus.util.xml.Xpp3Dom;
  
  import de.smartics.util.lang.StringFunction;
  
  /**
   * A helper to normalize the description value.
   */
  public final class MavenProjectWrapper extends MavenProject
  { // NOPMD
    // ********************************* Fields *********************************
  
    // --- constants ------------------------------------------------------------
  
    // --- members --------------------------------------------------------------
  
    /**
     * The Maven project being wrapped and fixed by this instance.
     */
    private final MavenProject wrapped;
  
    // ****************************** Initializer *******************************
  
    // ****************************** Constructors ******************************
  
    /**
     * Constructor.
     *
     * @param wrapped the Maven project being wrapped and fixed by this instance.
     */
    public MavenProjectWrapper(final MavenProject wrapped)
    {
      this.wrapped = wrapped;
    }
  
    // ****************************** Inner Classes *****************************
  
    // ********************************* Methods ********************************
  
    // --- init -----------------------------------------------------------------
  
    // --- get&set --------------------------------------------------------------
  
    // --- business -------------------------------------------------------------
  
    /**
     * Returns the project description.
     *
     * @return the project description or <code>null</code> if a description is
    *         not present.
    */
   @Override
   public String getDescription()
   {
     final String description = wrapped.getDescription();
     if (description != null)
     {
       final String normalizedDescription = StringFunction.strip(description);
       return normalizedDescription;
     }
     else
     {
       return null;
     }
   }
 
   // CHECKSTYLE:OFF
   @Override
   public String getName()
   {
     final String name = wrapped.getName();
     if (name != null)
     {
       final String normalizedName = StringFunction.strip(name);
       return normalizedName;
     }
     else
     {
       return name;
     }
   }
 
   @Override
   public String getModulePathAdjustment(final MavenProject moduleProject)
     throws IOException
   {
     return wrapped.getModulePathAdjustment(moduleProject);
   }
 
   @Override
   public Artifact getArtifact()
   {
     return wrapped.getArtifact();
   }
 
   @Override
   public void setArtifact(final Artifact artifact)
   {
     wrapped.setArtifact(artifact);
   }
 
   @Override
   public Model getModel()
   {
     return wrapped.getModel();
   }
 
   @Override
   public MavenProject getParent()
   {
     return wrapped.getParent();
   }
 
   @Override
   public void setParent(final MavenProject parent)
   {
     wrapped.setParent(parent);
   }
 
   @Override
   @SuppressWarnings("rawtypes")
   // NOPMD
   public void setRemoteArtifactRepositories(
       final List remoteArtifactRepositories)
   {
     wrapped.setRemoteArtifactRepositories(remoteArtifactRepositories);
   }
 
   public List<?> getRemoteArtifactRepositories()
   {
     return wrapped.getRemoteArtifactRepositories();
   }
 
   @Override
   public boolean hasParent()
   {
     return wrapped.hasParent();
   }
 
   @Override
   public File getFile()
   {
     return wrapped.getFile();
   }
 
   @Override
   public void setFile(final File file)
   {
     wrapped.setFile(file);
   }
 
   @Override
   public void setBasedir(final File basedir)
   {
     wrapped.setBasedir(basedir);
   }
 
   @Override
   public File getBasedir()
   {
     return wrapped.getBasedir();
   }
 
   @Override
   @SuppressWarnings("rawtypes")
   public void setDependencies(final List dependencies)
   {
     wrapped.setDependencies(dependencies);
   }
 
   @Override
   public List<?> getDependencies()
   {
     return wrapped.getDependencies();
   }
 
   @Override
   public DependencyManagement getDependencyManagement()
   {
     return wrapped.getDependencyManagement();
   }
 
   @Override
   public void addCompileSourceRoot(final String path)
   {
     wrapped.addCompileSourceRoot(path);
   }
 
   @Override
   public void addScriptSourceRoot(final String path)
   {
     wrapped.addScriptSourceRoot(path);
   }
 
   @Override
   public void addTestCompileSourceRoot(final String path)
   {
     wrapped.addTestCompileSourceRoot(path);
   }
 
   @Override
   public List<?> getCompileSourceRoots()
   {
     return wrapped.getCompileSourceRoots();
   }
 
   @Override
   public List<?> getScriptSourceRoots()
   {
     return wrapped.getScriptSourceRoots();
   }
 
   @Override
   public List<?> getTestCompileSourceRoots()
   {
     return wrapped.getTestCompileSourceRoots();
   }
 
   @Override
   public List<?> getCompileClasspathElements()
     throws DependencyResolutionRequiredException
   {
     return wrapped.getCompileClasspathElements();
   }
 
   @Override
   public List<?> getCompileArtifacts()
   {
     return wrapped.getCompileArtifacts();
   }
 
   @Override
   public List<?> getCompileDependencies()
   {
     return wrapped.getCompileDependencies();
   }
 
   @Override
   public List<?> getTestClasspathElements()
     throws DependencyResolutionRequiredException
   {
     return wrapped.getTestClasspathElements();
   }
 
   @Override
   public List<?> getTestArtifacts()
   {
     return wrapped.getTestArtifacts();
   }
 
   @Override
   public List<?> getTestDependencies()
   {
     return wrapped.getTestDependencies();
   }
 
   @Override
   public List<?> getRuntimeClasspathElements()
     throws DependencyResolutionRequiredException
   {
     return wrapped.getRuntimeClasspathElements();
   }
 
   @Override
   public List<?> getRuntimeArtifacts()
   {
     return wrapped.getRuntimeArtifacts();
   }
 
   @Override
   public List<?> getRuntimeDependencies()
   {
     return wrapped.getRuntimeDependencies();
   }
 
   @Override
   public List<?> getSystemClasspathElements()
     throws DependencyResolutionRequiredException
   {
     return wrapped.getSystemClasspathElements();
   }
 
   @Override
   public List<?> getSystemArtifacts()
   {
     return wrapped.getSystemArtifacts();
   }
 
   @Override
   public List<?> getSystemDependencies()
   {
     return wrapped.getSystemDependencies();
   }
 
   @Override
   public void setModelVersion(final String pomVersion)
   {
     wrapped.setModelVersion(pomVersion);
   }
 
   @Override
   public String getModelVersion()
   {
     return wrapped.getModelVersion();
   }
 
   @Override
   public String getId()
   {
     return wrapped.getId();
   }
 
   @Override
   public void setGroupId(final String groupId)
   {
     wrapped.setGroupId(groupId);
   }
 
   @Override
   public String getGroupId()
   {
     return wrapped.getGroupId();
   }
 
   @Override
   public void setArtifactId(final String artifactId)
   {
     wrapped.setArtifactId(artifactId);
   }
 
   @Override
   public String getArtifactId()
   {
     return wrapped.getArtifactId();
   }
 
   @Override
   public void setName(final String name)
   {
     wrapped.setName(name);
   }
 
   @Override
   public void setVersion(final String version)
   {
     wrapped.setVersion(version);
   }
 
   @Override
   public String getVersion()
   {
     return wrapped.getVersion();
   }
 
   @Override
   public String getPackaging()
   {
     return wrapped.getPackaging();
   }
 
   @Override
   public void setPackaging(final String packaging)
   {
     wrapped.setPackaging(packaging);
   }
 
   @Override
   public void setInceptionYear(final String inceptionYear)
   {
     wrapped.setInceptionYear(inceptionYear);
   }
 
   @Override
   public String getInceptionYear()
   {
     return wrapped.getInceptionYear();
   }
 
   @Override
   public void setUrl(final String url)
   {
     wrapped.setUrl(url);
   }
 
   @Override
   public String getUrl()
   {
     return wrapped.getUrl();
   }
 
   @Override
   public Prerequisites getPrerequisites()
   {
     return wrapped.getPrerequisites();
   }
 
   @Override
   public void setIssueManagement(final IssueManagement issueManagement)
   {
     wrapped.setIssueManagement(issueManagement);
   }
 
   @Override
   public CiManagement getCiManagement()
   {
     return wrapped.getCiManagement();
   }
 
   @Override
   public void setCiManagement(final CiManagement ciManagement)
   {
     wrapped.setCiManagement(ciManagement);
   }
 
   @Override
   public IssueManagement getIssueManagement()
   {
     return wrapped.getIssueManagement();
   }
 
   @Override
   public void setDistributionManagement(
       final DistributionManagement distributionManagement)
   {
     wrapped.setDistributionManagement(distributionManagement);
   }
 
   @Override
   public DistributionManagement getDistributionManagement()
   {
     return wrapped.getDistributionManagement();
   }
 
   @Override
   public void setDescription(final String description)
   {
     wrapped.setDescription(description);
   }
 
   @Override
   public void setOrganization(final Organization organization)
   {
     wrapped.setOrganization(organization);
   }
 
   @Override
   public Organization getOrganization()
   {
     return wrapped.getOrganization();
   }
 
   @Override
   public void setScm(final Scm scm)
   {
     wrapped.setScm(scm);
   }
 
   @Override
   public Scm getScm()
   {
     return wrapped.getScm();
   }
 
   @Override
   @SuppressWarnings("rawtypes")
   public void setMailingLists(final List mailingLists)
   {
     wrapped.setMailingLists(mailingLists);
   }
 
   @Override
   public List<?> getMailingLists()
   {
     return wrapped.getMailingLists();
   }
 
   @Override
   public void addMailingList(final MailingList mailingList)
   {
     wrapped.addMailingList(mailingList);
   }
 
   @Override
   @SuppressWarnings("rawtypes")
   public void setDevelopers(final List developers)
   {
     wrapped.setDevelopers(developers);
   }
 
   @Override
   public List<?> getDevelopers()
   {
     return wrapped.getDevelopers();
   }
 
   @Override
   public void addDeveloper(final Developer developer)
   {
     wrapped.addDeveloper(developer);
   }
 
   @Override
   @SuppressWarnings("rawtypes")
   public void setContributors(final List contributors)
   {
     wrapped.setContributors(contributors);
   }
 
   @Override
   public List<?> getContributors()
   {
     return wrapped.getContributors();
   }
 
   @Override
   public void addContributor(final Contributor contributor)
   {
     wrapped.addContributor(contributor);
   }
 
   @Override
   public void setBuild(final Build build)
   {
     wrapped.setBuild(build);
   }
 
   @Override
   public Build getBuild()
   {
     return wrapped.getBuild();
   }
 
   @Override
   public List<?> getResources()
   {
     return wrapped.getResources();
   }
 
   @Override
   public List<?> getTestResources()
   {
     return wrapped.getTestResources();
   }
 
   @Override
   public void addResource(final Resource resource)
   {
     wrapped.addResource(resource);
   }
 
   @Override
   public void addTestResource(final Resource testResource)
   {
     wrapped.addTestResource(testResource);
   }
 
   @Override
   public void setReporting(final Reporting reporting)
   {
     wrapped.setReporting(reporting);
   }
 
   @Override
   public Reporting getReporting()
   {
     return wrapped.getReporting();
   }
 
   @Override
   @SuppressWarnings("rawtypes")
   public void setLicenses(final List licenses)
   {
     wrapped.setLicenses(licenses);
   }
 
   @Override
   public List<?> getLicenses()
   {
     return wrapped.getLicenses();
   }
 
   @Override
   public void addLicense(final License license)
   {
     wrapped.addLicense(license);
   }
 
   @Override
   @SuppressWarnings("rawtypes")
   public void setArtifacts(final Set artifacts)
   {
     wrapped.setArtifacts(artifacts);
   }
 
   @Override
   @SuppressWarnings("rawtypes")
   public Set getArtifacts()
   {
     return wrapped.getArtifacts();
   }
 
   @Override
   @SuppressWarnings("rawtypes")
   public Map getArtifactMap()
   {
     return wrapped.getArtifactMap();
   }
 
   @Override
   @SuppressWarnings("rawtypes")
   public void setPluginArtifacts(final Set pluginArtifacts)
   {
     wrapped.setPluginArtifacts(pluginArtifacts);
   }
 
   @Override
   @SuppressWarnings("rawtypes")
   public Set getPluginArtifacts()
   {
     return wrapped.getPluginArtifacts();
   }
 
   @Override
   @SuppressWarnings("rawtypes")
   public Map getPluginArtifactMap()
   {
     return wrapped.getPluginArtifactMap();
   }
 
   @Override
   @SuppressWarnings("rawtypes")
   public void setReportArtifacts(final Set reportArtifacts)
   {
     wrapped.setReportArtifacts(reportArtifacts);
   }
 
   @Override
   @SuppressWarnings("rawtypes")
   public Set getReportArtifacts()
   {
     return wrapped.getReportArtifacts();
   }
 
   @Override
   @SuppressWarnings("rawtypes")
   public Map getReportArtifactMap()
   {
     return wrapped.getReportArtifactMap();
   }
 
   @Override
   @SuppressWarnings("rawtypes")
   public void setExtensionArtifacts(final Set extensionArtifacts)
   {
     wrapped.setExtensionArtifacts(extensionArtifacts);
   }
 
   @Override
   @SuppressWarnings("rawtypes")
   public Set getExtensionArtifacts()
   {
     return wrapped.getExtensionArtifacts();
   }
 
   @Override
   @SuppressWarnings("rawtypes")
   public Map getExtensionArtifactMap()
   {
     return wrapped.getExtensionArtifactMap();
   }
 
   @Override
   public void setParentArtifact(final Artifact parentArtifact)
   {
     wrapped.setParentArtifact(parentArtifact);
   }
 
   @Override
   public Artifact getParentArtifact()
   {
     return wrapped.getParentArtifact();
   }
 
   @Override
   public List<?> getRepositories()
   {
     return wrapped.getRepositories();
   }
 
   @Override
   public List<?> getReportPlugins()
   {
     return wrapped.getReportPlugins();
   }
 
   @Override
   public List<?> getBuildPlugins()
   {
     return wrapped.getBuildPlugins();
   }
 
   @Override
   public List<?> getModules()
   {
     return wrapped.getModules();
   }
 
   @Override
   public PluginManagement getPluginManagement()
   {
     return wrapped.getPluginManagement();
   }
 
   @Override
   public void addPlugin(final Plugin plugin)
   {
     wrapped.addPlugin(plugin);
   }
 
   @Override
   public void injectPluginManagementInfo(final Plugin plugin)
   {
     wrapped.injectPluginManagementInfo(plugin);
   }
 
   @Override
   public List<?> getCollectedProjects()
   {
     return wrapped.getCollectedProjects();
   }
 
   @Override
   @SuppressWarnings("rawtypes")
   public void setCollectedProjects(final List collectedProjects)
   {
     wrapped.setCollectedProjects(collectedProjects);
   }
 
   @Override
   @SuppressWarnings("rawtypes")
   public void setPluginArtifactRepositories(
       final List pluginArtifactRepositories)
   {
     wrapped.setPluginArtifactRepositories(pluginArtifactRepositories);
   }
 
   @Override
   public List<?> getPluginArtifactRepositories()
   {
     return wrapped.getPluginArtifactRepositories();
   }
 
   @Override
   public ArtifactRepository getDistributionManagementArtifactRepository()
   {
     return wrapped.getDistributionManagementArtifactRepository();
   }
 
   @Override
   public List<?> getPluginRepositories()
   {
     return wrapped.getPluginRepositories();
   }
 
   @Override
   @SuppressWarnings("rawtypes")
   public void setActiveProfiles(final List activeProfiles)
   {
     wrapped.setActiveProfiles(activeProfiles);
   }
 
   @Override
   public List<?> getActiveProfiles()
   {
     return wrapped.getActiveProfiles();
   }
 
   @Override
   public void addAttachedArtifact(final Artifact artifact)
   {
     wrapped.addAttachedArtifact(artifact);
   }
 
   @Override
   public List<?> getAttachedArtifacts()
   {
     return wrapped.getAttachedArtifacts();
   }
 
   @Override
   public Xpp3Dom getGoalConfiguration(final String pluginGroupId,
       final String pluginArtifactId, final String executionId,
       final String goalId)
   {
     return wrapped.getGoalConfiguration(pluginGroupId, pluginArtifactId,
         executionId, goalId);
   }
 
   @Override
   public Xpp3Dom getReportConfiguration(final String pluginGroupId,
       final String pluginArtifactId, final String reportSetId)
   {
     return wrapped.getReportConfiguration(pluginGroupId, pluginArtifactId,
         reportSetId);
   }
 
   @Override
   public MavenProject getExecutionProject()
   {
     return wrapped.getExecutionProject();
   }
 
   @Override
   public void setExecutionProject(final MavenProject executionProject)
   {
     wrapped.setExecutionProject(executionProject);
   }
 
   @Override
   public void writeModel(final Writer writer) throws IOException
   {
     wrapped.writeModel(writer);
   }
 
   @Override
   public void writeOriginalModel(final Writer writer) throws IOException
   {
     wrapped.writeOriginalModel(writer);
   }
 
   @Override
   @SuppressWarnings("rawtypes")
   public Set getDependencyArtifacts()
   {
     return wrapped.getDependencyArtifacts();
   }
 
   @Override
   @SuppressWarnings("rawtypes")
   public void setDependencyArtifacts(final Set dependencyArtifacts)
   {
     wrapped.setDependencyArtifacts(dependencyArtifacts);
   }
 
   @Override
   public void setReleaseArtifactRepository(
       final ArtifactRepository releaseArtifactRepository)
   {
     wrapped.setReleaseArtifactRepository(releaseArtifactRepository);
   }
 
   @Override
   public void setSnapshotArtifactRepository(
       final ArtifactRepository snapshotArtifactRepository)
   {
     wrapped.setSnapshotArtifactRepository(snapshotArtifactRepository);
   }
 
   @Override
   public void setOriginalModel(final Model originalModel)
   {
     wrapped.setOriginalModel(originalModel);
   }
 
   @Override
   public Model getOriginalModel()
   {
     return wrapped.getOriginalModel();
   }
 
   @Override
   @SuppressWarnings("rawtypes")
   public void setManagedVersionMap(final Map map)
   {
     wrapped.setManagedVersionMap(map);
   }
 
   @Override
   @SuppressWarnings("rawtypes")
   public Map getManagedVersionMap()
   {
     return wrapped.getManagedVersionMap();
   }
 
   @Override
   public boolean equals(final Object other)
   {
     return wrapped.equals(other);
   }
 
   @Override
   public int hashCode()
   {
     return wrapped.hashCode();
   }
 
   @Override
   public List<?> getBuildExtensions()
   {
     return wrapped.getBuildExtensions();
   }
 
   @Override
   @SuppressWarnings("rawtypes")
   public Set createArtifacts(final ArtifactFactory artifactFactory,
       final String inheritedScope, final ArtifactFilter dependencyFilter)
     throws InvalidDependencyVersionException
   {
     return wrapped.createArtifacts(artifactFactory, inheritedScope,
         dependencyFilter);
   }
 
   @Override
   public void addProjectReference(final MavenProject project)
   {
     wrapped.addProjectReference(project);
   }
 
   @Override
   @Deprecated
   public void attachArtifact(final String type, final String classifier,
       final File file)
   {
     wrapped.attachArtifact(type, classifier, file);
   }
 
   @Override
   public Properties getProperties()
   {
     return wrapped.getProperties();
   }
 
   @Override
   public List<?> getFilters()
   {
     return wrapped.getFilters();
   }
 
   @Override
   @SuppressWarnings("rawtypes")
   public Map getProjectReferences()
   {
     return wrapped.getProjectReferences();
   }
 
   @Override
   public boolean isExecutionRoot()
   {
     return wrapped.isExecutionRoot();
   }
 
   @Override
   public void setExecutionRoot(final boolean executionRoot)
   {
     wrapped.setExecutionRoot(executionRoot);
   }
 
   @Override
   public String getDefaultGoal()
   {
     return wrapped.getDefaultGoal();
   }
 
   @Override
   public void resolveActiveArtifacts()
   {
     wrapped.resolveActiveArtifacts();
   }
 
   @Override
   public Artifact replaceWithActiveArtifact(final Artifact pluginArtifact)
   {
     return wrapped.replaceWithActiveArtifact(pluginArtifact);
   }
 
   @Override
   public String toString()
   {
     return wrapped.toString();
   }
 
   @Override
   public boolean isConcrete()
   {
     return wrapped.isConcrete();
   }
 
   @Override
   public void setConcrete(final boolean concrete)
   {
     wrapped.setConcrete(concrete);
   }
 
   @Override
   public Build getDynamicBuild()
   {
     return wrapped.getDynamicBuild();
   }
 
   @Override
   public Build getOriginalInterpolatedBuild()
   {
     return wrapped.getOriginalInterpolatedBuild();
   }
 
   public List<?> getDynamicCompileSourceRoots()
   {
     return wrapped.getDynamicCompileSourceRoots();
   }
 
   @Override
   public List<?> getOriginalInterpolatedCompileSourceRoots()
   {
     return wrapped.getOriginalInterpolatedCompileSourceRoots();
   }
 
   @Override
   public List<?> getDynamicTestCompileSourceRoots()
   {
     return wrapped.getDynamicTestCompileSourceRoots();
   }
 
   @Override
   public List<?> getOriginalInterpolatedTestCompileSourceRoots()
   {
     return wrapped.getOriginalInterpolatedTestCompileSourceRoots();
   }
 
   @Override
   public List<?> getDynamicScriptSourceRoots()
   {
     return wrapped.getDynamicScriptSourceRoots();
   }
 
   @Override
   public List<?> getOriginalInterpolatedScriptSourceRoots()
   {
     return wrapped.getOriginalInterpolatedScriptSourceRoots();
   }
 
   @Override
   public void clearRestorableRoots()
   {
     wrapped.clearRestorableRoots();
   }
 
   @Override
   public void clearRestorableBuild()
   {
     wrapped.clearRestorableBuild();
   }
 
   @Override
   @SuppressWarnings("rawtypes")
   public void preserveCompileSourceRoots(
       final List originalInterpolatedCompileSourceRoots) // NOPMD
   {
     wrapped.preserveCompileSourceRoots(originalInterpolatedCompileSourceRoots);
   }
 
   @Override
   @SuppressWarnings("rawtypes")
   public void preserveTestCompileSourceRoots(
       final List originalInterpolatedTestCompileSourceRoots)
   {
     wrapped
         .preserveTestCompileSourceRoots(originalInterpolatedTestCompileSourceRoots);
   }
 
   @Override
   @SuppressWarnings("rawtypes")
   public void preserveScriptSourceRoots(
       final List originalInterpolatedScriptSourceRoots) // NOPMD
   {
     wrapped.preserveScriptSourceRoots(originalInterpolatedScriptSourceRoots);
   }
 
   @Override
   public void preserveBuild(final Build originalInterpolatedBuild)
   {
     wrapped.preserveBuild(originalInterpolatedBuild);
   }
 
   @Override
   public Properties getPreservedProperties()
   {
     return wrapped.getPreservedProperties();
   }
 
   @Override
   public void preserveProperties()
   {
     wrapped.preserveProperties();
   }
 
   @Override
   public File getPreservedBasedir()
   {
     return wrapped.getPreservedBasedir();
   }
 
   @Override
   public void preserveBasedir()
   {
     wrapped.preserveBasedir();
   }
 
   @Override
   public void setLogger(final Logger logger)
   {
     wrapped.setLogger(logger);
   }
 
   @Override
   public ProjectBuilderConfiguration getProjectBuilderConfiguration()
   {
     return wrapped.getProjectBuilderConfiguration();
   }
 
   @Override
   public void setProjectBuilderConfiguration(
       final ProjectBuilderConfiguration projectBuilderConfiguration)
   {
     wrapped.setProjectBuilderConfiguration(projectBuilderConfiguration);
   }
 
   // CHECKSTYLE:ON
 
   // --- object basics --------------------------------------------------------
 
 }