Coverage Report

 package org.apache.maven.shared.filtering;
 
 /*
  * 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 java.io.File;
 import java.io.Reader;
 import java.util.ArrayList;
 import java.util.List;
 
 import org.apache.maven.execution.MavenSession;
 import org.apache.maven.project.MavenProject;
 import org.codehaus.plexus.interpolation.Interpolator;
 import org.codehaus.plexus.interpolation.RegexBasedInterpolator;
 import org.codehaus.plexus.interpolation.StringSearchInterpolator;
 import org.codehaus.plexus.interpolation.ValueSource;
 import org.codehaus.plexus.util.FileUtils;
 import org.codehaus.plexus.util.FileUtils.FilterWrapper;
 
 /**
  * A bean to configure a resources filtering execution.
  *
  * @author <a href="mailto:olamy@apache.org">olamy</a>
  * @version $Id: MavenResourcesExecution.java 1057398 2011-01-10 22:18:08Z dennisl $
  */
 public class MavenResourcesExecution
     extends AbstractMavenFilteringRequest
 {
    
     /** @see org.apache.maven.model.Resource  */
     private List resources;
 
     private File outputDirectory;
 
     private List nonFilteredFileExtensions;
 
     /** @see FileUtils.FilterWrapper */
     private List filterWrappers;
 
     private File resourcesBaseDirectory;
 
     private boolean useDefaultFilterWrappers = false;
     
     /**
      * Overwrite existing files even if the destination files are newer.
      * <code>false</code> by default.
      *
      * @since 1.0-beta-2
      */
     private boolean overwrite = false;
     
     /**
      * Copy any empty directories included in the Resources.
      *
      * @since 1.0-beta-2
      */
     private boolean includeEmptyDirs = false;
     
     /**
      * Do not stop trying to filter tokens when reaching EOL.
      *
      * @since 1.0
      */
     private boolean supportMultiLineFiltering;    
     
     public MavenResourcesExecution()
     {
         // no op
     }
     
     /**
      * As we use a Maven project <code>useDefaultFilterWrappers</code> will be set to <code>true</code>.
      *
      * @param resources
      * @param outputDirectory
      * @param mavenProject
      * @param encoding
      * @param fileFilters
      * @param nonFilteredFileExtensions
      * @param mavenSession
      */
     public MavenResourcesExecution( List resources, File outputDirectory, MavenProject mavenProject, String encoding,
                                     List fileFilters, List nonFilteredFileExtensions, MavenSession mavenSession )
     {
         super( mavenProject, fileFilters, encoding, mavenSession );
         this.resources = resources;
         this.outputDirectory = outputDirectory;
         this.nonFilteredFileExtensions = nonFilteredFileExtensions;
         this.useDefaultFilterWrappers = true;
         this.resourcesBaseDirectory = mavenProject.getBasedir();
     }
 
     public MavenResourcesExecution( List resources, File outputDirectory, String encoding, List filterWrappers,
                                     File resourcesBaseDirectory, List nonFilteredFileExtensions )
     {
         this();
         this.resources = resources;
         this.outputDirectory = outputDirectory;
         this.filterWrappers = filterWrappers;
         this.nonFilteredFileExtensions = nonFilteredFileExtensions;
         this.resourcesBaseDirectory = resourcesBaseDirectory;
         this.useDefaultFilterWrappers = false;
         setEncoding( encoding );
     }
 
     
     /**
      * @return List of {@link org.apache.maven.model.Resource}
      */
     public List getResources()
     {
         return resources;
     }
 
     /**
      * @param resources List of {@link org.apache.maven.model.Resource}
      */
     public void setResources( List resources )
     {
         this.resources = resources;
     }
 
     public File getOutputDirectory()
     {
         return outputDirectory;
     }
 
     public void setOutputDirectory( File outputDirectory )
     {
         this.outputDirectory = outputDirectory;
     }
 
     /**
      * @return List of {@link String} file extensions to not filter
      */
     public List getNonFilteredFileExtensions()
     {
         return nonFilteredFileExtensions;
     }
 
     /**
      * @param nonFilteredFileExtensions List of {@link String} file extensions to not filter
      */
     public void setNonFilteredFileExtensions( List nonFilteredFileExtensions )
     {
         this.nonFilteredFileExtensions = nonFilteredFileExtensions;
     }
 
     /**
      * @return List of {@link FileUtils.FilterWrapper}
      */
     public List getFilterWrappers()
     {
         return filterWrappers;
     }
 
     /**
      * @param filterWrappers List of {@link FileUtils.FilterWrapper}
      */
     public void setFilterWrappers( List filterWrappers )
     {
         this.filterWrappers = filterWrappers;
     }
     
     public void addFilterWrapper( FilterWrapper filterWrapper )
     {
         if ( this.filterWrappers == null )
         {
             this.filterWrappers = new ArrayList();
         }
         this.filterWrappers.add( filterWrapper );
     }
     
     /**
      * Helper to add {@link FileUtils.FilterWrapper}, will {@link RegexBasedInterpolator} with default regex Exp ${ } 
      * and InterpolatorFilterReaderLineEnding with defaultTokens ${ }.
      *
      * @param valueSource 
      * @deprecated This doesn't support escaping use {@link #addFilerWrapperWithEscaping(ValueSource, String, String, String, boolean)}
      */
     public void addFilerWrapper( final ValueSource valueSource )
     {
         addFilterWrapper( new FileUtils.FilterWrapper()
         {
             public Reader getReader( Reader reader )
             {
                 Interpolator propertiesInterpolator = new RegexBasedInterpolator();
                 propertiesInterpolator.addValueSource( valueSource );
                 return new InterpolatorFilterReaderLineEnding( reader, propertiesInterpolator,
                                                                InterpolatorFilterReaderLineEnding.DEFAULT_BEGIN_TOKEN,
                                                                InterpolatorFilterReaderLineEnding.DEFAULT_END_TOKEN,
                                                                false );
             }
         } );
     }
 
     /**
      * @param valueSource
      * @param startRegExp
      * @param endRegExp
      * @param startToken
      * @param endToken
      * @deprecated This doesn't support escaping use {@link #addFilerWrapperWithEscaping(ValueSource, String, String, String, boolean)}
      */
     public void addFilerWrapper( final ValueSource valueSource, final String startRegExp, final String endRegExp,
                                  final String startToken, final String endToken )
     {
         addFilterWrapper( new FileUtils.FilterWrapper()
         {
             public Reader getReader( Reader reader )
             {
                 Interpolator propertiesInterpolator = new RegexBasedInterpolator( startRegExp, endRegExp );
                 propertiesInterpolator.addValueSource( valueSource );
                 return new InterpolatorFilterReaderLineEnding( reader, propertiesInterpolator, startToken, endToken,
                                                                false );
             }
         } );
     }  
     
     /**
      * @param valueSource
      * @param startExp start token like ${
      * @param endExp endToken }
      * @since 1.0-beta-2
      * @param escapeString
      * @deprecated This doesn't support escaping use {@link #addFilerWrapperWithEscaping(ValueSource, String, String, String, boolean)}
      */
     public void addFilerWrapperWithEscaping( final ValueSource valueSource, final String startExp, final String endExp,
                                              final String escapeString )
     {
         addFilterWrapper( new FileUtils.FilterWrapper()
         {
             public Reader getReader( Reader reader )
             {
                 StringSearchInterpolator propertiesInterpolator = new StringSearchInterpolator( startExp, endExp );
                 propertiesInterpolator.addValueSource( valueSource );
                 propertiesInterpolator.setEscapeString( escapeString );
                 InterpolatorFilterReaderLineEnding interpolatorFilterReader
                     = new InterpolatorFilterReaderLineEnding( reader,
                                                               propertiesInterpolator,
                                                               startExp, endExp, false );
                 interpolatorFilterReader.setInterpolateWithPrefixPattern( false );
                 return interpolatorFilterReader;
             }
         } );
     } 
     
     /**
      * @param valueSource
      * @param startExp start token like ${
      * @param endExp endToken }
      * @param escapeString
      * @param supportMultiLineFiltering do we support or use filtering on multi lines with start and endtoken on multi lines
      * @since 1.0
      */
     public void addFilerWrapperWithEscaping( final ValueSource valueSource, final String startExp, final String endExp,
                                              final String escapeString, final boolean supportMultiLineFiltering )
     {
         addFilterWrapper( new FileUtils.FilterWrapper()
         {
             public Reader getReader( Reader reader )
             {
                 StringSearchInterpolator propertiesInterpolator = new StringSearchInterpolator( startExp, endExp );
                 propertiesInterpolator.addValueSource( valueSource );
                 propertiesInterpolator.setEscapeString( escapeString );
                 InterpolatorFilterReaderLineEnding interpolatorFilterReader
                     = new InterpolatorFilterReaderLineEnding( reader,
                                                               propertiesInterpolator,
                                                               startExp, endExp, supportMultiLineFiltering );
                 interpolatorFilterReader.setInterpolateWithPrefixPattern( false );
                 return interpolatorFilterReader;
             }
         } );
     }    
     
     
     public File getResourcesBaseDirectory()
     {
         return resourcesBaseDirectory;
     }
 
     public void setResourcesBaseDirectory( File resourcesBaseDirectory )
     {
         this.resourcesBaseDirectory = resourcesBaseDirectory;
     }
 
     public boolean isUseDefaultFilterWrappers()
     {
         return useDefaultFilterWrappers;
     }
 
     public void setUseDefaultFilterWrappers( boolean useDefaultFilterWrappers )
     {
         this.useDefaultFilterWrappers = useDefaultFilterWrappers;
     }
 
     /**
      * Overwrite existing files even if the destination files are newer.
      *
      * @since 1.0-beta-2
      */
     public boolean isOverwrite()
     {
         return overwrite;
     }
 
     /**
      * Overwrite existing files even if the destination files are newer.
      *
      * @param overwrite
      * @since 1.0-beta-2
      */
     public void setOverwrite( boolean overwrite )
     {
         this.overwrite = overwrite;
     }
 
     /**
      * Copy any empty directories included in the Resources.
      *
      * @since 1.0-beta-2
      */
     public boolean isIncludeEmptyDirs()
     {
         return includeEmptyDirs;
     }
 
     /**
      * Copy any empty directories included in the Resources.
      *
      * @param includeEmptyDirs
      * @since 1.0-beta-2
      */
     public void setIncludeEmptyDirs( boolean includeEmptyDirs )
     {
         this.includeEmptyDirs = includeEmptyDirs;
     }
     
     public MavenResourcesExecution copyOf()
     {
         MavenResourcesExecution mre = new MavenResourcesExecution();
         mre.setAdditionalProperties( mre.getAdditionalProperties() );
         mre.setEncoding( mre.getEncoding() );
         mre.setEscapedBackslashesInFilePath( mre.isEscapedBackslashesInFilePath() );
         mre.setEscapeString( mre.getEscapeString() );
         mre.setFileFilters( copyList( mre.getFileFilters() ) );
         mre.setFilterWrappers( copyList( mre.getFilterWrappers() ) );
         mre.setIncludeEmptyDirs( mre.isIncludeEmptyDirs() );
         mre.setInjectProjectBuildFilters( mre.isInjectProjectBuildFilters() );
         mre.setMavenProject( mre.getMavenProject() );
         mre.setMavenSession( mre.getMavenSession() );
         mre.setNonFilteredFileExtensions( copyList( mre.getNonFilteredFileExtensions() ) );
         mre.setOutputDirectory( mre.getOutputDirectory() );
         mre.setOverwrite( mre.isOverwrite() );
         mre.setProjectStartExpressions( copyList( mre.getProjectStartExpressions() ) );
         mre.setResources( copyList( mre.getResources() ) );
         mre.setResourcesBaseDirectory( mre.getResourcesBaseDirectory() );
         mre.setUseDefaultFilterWrappers( mre.isUseDefaultFilterWrappers() );
         mre.setSupportMultiLineFiltering( mre.isSupportMultiLineFiltering() );
         return mre;
     }
    
     private List copyList( List lst )
     {
         if ( lst == null )
         {
             return null;
         }
         else if ( lst.isEmpty() )
         {
             return new ArrayList();
         }
         else
         {
             return new ArrayList( lst );
         }
     }
 
     public boolean isSupportMultiLineFiltering()
     {
         return supportMultiLineFiltering;
     }
 
     public void setSupportMultiLineFiltering( boolean supportMultiLineFiltering )
     {
         this.supportMultiLineFiltering = supportMultiLineFiltering;
     }
 }

1		package org.apache.maven.shared.filtering;
2
3		/*
4		* Licensed to the Apache Software Foundation (ASF) under one
5		* or more contributor license agreements. See the NOTICE file
6		* distributed with this work for additional information
7		* regarding copyright ownership. The ASF licenses this file
8		* to you under the Apache License, Version 2.0 (the
9		* "License"); you may not use this file except in compliance
10		* with the License. You may obtain a copy of the License at
11		*
12		* http://www.apache.org/licenses/LICENSE-2.0
13		*
14		* Unless required by applicable law or agreed to in writing,
15		* software distributed under the License is distributed on an
16		* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
17		* KIND, either express or implied. See the License for the
18		* specific language governing permissions and limitations
19		* under the License.
20		*/
21
22		import java.io.File;
23		import java.io.Reader;
24		import java.util.ArrayList;
25		import java.util.List;
26
27		import org.apache.maven.execution.MavenSession;
28		import org.apache.maven.project.MavenProject;
29		import org.codehaus.plexus.interpolation.Interpolator;
30		import org.codehaus.plexus.interpolation.RegexBasedInterpolator;
31		import org.codehaus.plexus.interpolation.StringSearchInterpolator;
32		import org.codehaus.plexus.interpolation.ValueSource;
33		import org.codehaus.plexus.util.FileUtils;
34		import org.codehaus.plexus.util.FileUtils.FilterWrapper;
35
36		/**
37		* A bean to configure a resources filtering execution.
38		*
39		* @author <a href="mailto:olamy@apache.org">olamy</a>
40		* @version $Id: MavenResourcesExecution.java 1057398 2011-01-10 22:18:08Z dennisl $
41		*/
42		public class MavenResourcesExecution
43		extends AbstractMavenFilteringRequest
44		{
45
46		/** @see org.apache.maven.model.Resource */
47		private List resources;
48
49		private File outputDirectory;
50
51		private List nonFilteredFileExtensions;
52
53		/** @see FileUtils.FilterWrapper */
54		private List filterWrappers;
55
56		private File resourcesBaseDirectory;
57
58	27	private boolean useDefaultFilterWrappers = false;
59
60		/**
61		* Overwrite existing files even if the destination files are newer.
62		* <code>false</code> by default.
63		*
64		* @since 1.0-beta-2
65		*/
66	27	private boolean overwrite = false;
67
68		/**
69		* Copy any empty directories included in the Resources.
70		*
71		* @since 1.0-beta-2
72		*/
73	27	private boolean includeEmptyDirs = false;
74
75		/**
76		* Do not stop trying to filter tokens when reaching EOL.
77		*
78		* @since 1.0
79		*/
80		private boolean supportMultiLineFiltering;
81
82		public MavenResourcesExecution()
83	3	{
84		// no op
85	3	}
86
87		/**
88		* As we use a Maven project <code>useDefaultFilterWrappers</code> will be set to <code>true</code>.
89		*
90		* @param resources
91		* @param outputDirectory
92		* @param mavenProject
93		* @param encoding
94		* @param fileFilters
95		* @param nonFilteredFileExtensions
96		* @param mavenSession
97		*/
98		public MavenResourcesExecution( List resources, File outputDirectory, MavenProject mavenProject, String encoding,
99		List fileFilters, List nonFilteredFileExtensions, MavenSession mavenSession )
100		{
101	24	super( mavenProject, fileFilters, encoding, mavenSession );
102	24	this.resources = resources;
103	24	this.outputDirectory = outputDirectory;
104	24	this.nonFilteredFileExtensions = nonFilteredFileExtensions;
105	24	this.useDefaultFilterWrappers = true;
106	24	this.resourcesBaseDirectory = mavenProject.getBasedir();
107	24	}
108
109		public MavenResourcesExecution( List resources, File outputDirectory, String encoding, List filterWrappers,
110		File resourcesBaseDirectory, List nonFilteredFileExtensions )
111		{
112	0	this();
113	0	this.resources = resources;
114	0	this.outputDirectory = outputDirectory;
115	0	this.filterWrappers = filterWrappers;
116	0	this.nonFilteredFileExtensions = nonFilteredFileExtensions;
117	0	this.resourcesBaseDirectory = resourcesBaseDirectory;
118	0	this.useDefaultFilterWrappers = false;
119	0	setEncoding( encoding );
120	0	}
121
122
123		/**
124		* @return List of {@link org.apache.maven.model.Resource}
125		*/
126		public List getResources()
127		{
128	48	return resources;
129		}
130
131		/**
132		* @param resources List of {@link org.apache.maven.model.Resource}
133		*/
134		public void setResources( List resources )
135		{
136	0	this.resources = resources;
137	0	}
138
139		public File getOutputDirectory()
140		{
141	54	return outputDirectory;
142		}
143
144		public void setOutputDirectory( File outputDirectory )
145		{
146	0	this.outputDirectory = outputDirectory;
147	0	}
148
149		/**
150		* @return List of {@link String} file extensions to not filter
151		*/
152		public List getNonFilteredFileExtensions()
153		{
154	69	return nonFilteredFileExtensions;
155		}
156
157		/**
158		* @param nonFilteredFileExtensions List of {@link String} file extensions to not filter
159		*/
160		public void setNonFilteredFileExtensions( List nonFilteredFileExtensions )
161		{
162	0	this.nonFilteredFileExtensions = nonFilteredFileExtensions;
163	0	}
164
165		/**
166		* @return List of {@link FileUtils.FilterWrapper}
167		*/
168		public List getFilterWrappers()
169		{
170	94	return filterWrappers;
171		}
172
173		/**
174		* @param filterWrappers List of {@link FileUtils.FilterWrapper}
175		*/
176		public void setFilterWrappers( List filterWrappers )
177		{
178	24	this.filterWrappers = filterWrappers;
179	24	}
180
181		public void addFilterWrapper( FilterWrapper filterWrapper )
182		{
183	1	if ( this.filterWrappers == null )
184		{
185	1	this.filterWrappers = new ArrayList();
186		}
187	1	this.filterWrappers.add( filterWrapper );
188	1	}
189
190		/**
191		* Helper to add {@link FileUtils.FilterWrapper}, will {@link RegexBasedInterpolator} with default regex Exp ${ }
192		* and InterpolatorFilterReaderLineEnding with defaultTokens ${ }.
193		*
194		* @param valueSource
195		* @deprecated This doesn't support escaping use {@link #addFilerWrapperWithEscaping(ValueSource, String, String, String, boolean)}
196		*/
197		public void addFilerWrapper( final ValueSource valueSource )
198		{
199	0	addFilterWrapper( new FileUtils.FilterWrapper()
200		{
201	0	public Reader getReader( Reader reader )
202		{
203	0	Interpolator propertiesInterpolator = new RegexBasedInterpolator();
204	0	propertiesInterpolator.addValueSource( valueSource );
205	0	return new InterpolatorFilterReaderLineEnding( reader, propertiesInterpolator,
206		InterpolatorFilterReaderLineEnding.DEFAULT_BEGIN_TOKEN,
207		InterpolatorFilterReaderLineEnding.DEFAULT_END_TOKEN,
208		false );
209		}
210		} );
211	0	}
212
213		/**
214		* @param valueSource
215		* @param startRegExp
216		* @param endRegExp
217		* @param startToken
218		* @param endToken
219		* @deprecated This doesn't support escaping use {@link #addFilerWrapperWithEscaping(ValueSource, String, String, String, boolean)}
220		*/
221		public void addFilerWrapper( final ValueSource valueSource, final String startRegExp, final String endRegExp,
222		final String startToken, final String endToken )
223		{
224	0	addFilterWrapper( new FileUtils.FilterWrapper()
225		{
226	0	public Reader getReader( Reader reader )
227		{
228	0	Interpolator propertiesInterpolator = new RegexBasedInterpolator( startRegExp, endRegExp );
229	0	propertiesInterpolator.addValueSource( valueSource );
230	0	return new InterpolatorFilterReaderLineEnding( reader, propertiesInterpolator, startToken, endToken,
231		false );
232		}
233		} );
234	0	}
235
236		/**
237		* @param valueSource
238		* @param startExp start token like ${
239		* @param endExp endToken }
240		* @since 1.0-beta-2
241		* @param escapeString
242		* @deprecated This doesn't support escaping use {@link #addFilerWrapperWithEscaping(ValueSource, String, String, String, boolean)}
243		*/
244		public void addFilerWrapperWithEscaping( final ValueSource valueSource, final String startExp, final String endExp,
245		final String escapeString )
246		{
247	1	addFilterWrapper( new FileUtils.FilterWrapper()
248		{
249	1	public Reader getReader( Reader reader )
250		{
251	7	StringSearchInterpolator propertiesInterpolator = new StringSearchInterpolator( startExp, endExp );
252	7	propertiesInterpolator.addValueSource( valueSource );
253	7	propertiesInterpolator.setEscapeString( escapeString );
254	7	InterpolatorFilterReaderLineEnding interpolatorFilterReader
255		= new InterpolatorFilterReaderLineEnding( reader,
256		propertiesInterpolator,
257		startExp, endExp, false );
258	7	interpolatorFilterReader.setInterpolateWithPrefixPattern( false );
259	7	return interpolatorFilterReader;
260		}
261		} );
262	1	}
263
264		/**
265		* @param valueSource
266		* @param startExp start token like ${
267		* @param endExp endToken }
268		* @param escapeString
269		* @param supportMultiLineFiltering do we support or use filtering on multi lines with start and endtoken on multi lines
270		* @since 1.0
271		*/
272		public void addFilerWrapperWithEscaping( final ValueSource valueSource, final String startExp, final String endExp,
273		final String escapeString, final boolean supportMultiLineFiltering )
274		{
275	0	addFilterWrapper( new FileUtils.FilterWrapper()
276		{
277	0	public Reader getReader( Reader reader )
278		{
279	0	StringSearchInterpolator propertiesInterpolator = new StringSearchInterpolator( startExp, endExp );
280	0	propertiesInterpolator.addValueSource( valueSource );
281	0	propertiesInterpolator.setEscapeString( escapeString );
282	0	InterpolatorFilterReaderLineEnding interpolatorFilterReader
283		= new InterpolatorFilterReaderLineEnding( reader,
284		propertiesInterpolator,
285		startExp, endExp, supportMultiLineFiltering );
286	0	interpolatorFilterReader.setInterpolateWithPrefixPattern( false );
287	0	return interpolatorFilterReader;
288		}
289		} );
290	0	}
291
292
293		public File getResourcesBaseDirectory()
294		{
295	0	return resourcesBaseDirectory;
296		}
297
298		public void setResourcesBaseDirectory( File resourcesBaseDirectory )
299		{
300	0	this.resourcesBaseDirectory = resourcesBaseDirectory;
301	0	}
302
303		public boolean isUseDefaultFilterWrappers()
304		{
305	24	return useDefaultFilterWrappers;
306		}
307
308		public void setUseDefaultFilterWrappers( boolean useDefaultFilterWrappers )
309		{
310	14	this.useDefaultFilterWrappers = useDefaultFilterWrappers;
311	14	}
312
313		/**
314		* Overwrite existing files even if the destination files are newer.
315		*
316		* @since 1.0-beta-2
317		*/
318		public boolean isOverwrite()
319		{
320	69	return overwrite;
321		}
322
323		/**
324		* Overwrite existing files even if the destination files are newer.
325		*
326		* @param overwrite
327		* @since 1.0-beta-2
328		*/
329		public void setOverwrite( boolean overwrite )
330		{
331	0	this.overwrite = overwrite;
332	0	}
333
334		/**
335		* Copy any empty directories included in the Resources.
336		*
337		* @since 1.0-beta-2
338		*/
339		public boolean isIncludeEmptyDirs()
340		{
341	25	return includeEmptyDirs;
342		}
343
344		/**
345		* Copy any empty directories included in the Resources.
346		*
347		* @param includeEmptyDirs
348		* @since 1.0-beta-2
349		*/
350		public void setIncludeEmptyDirs( boolean includeEmptyDirs )
351		{
352	2	this.includeEmptyDirs = includeEmptyDirs;
353	2	}
354
355		public MavenResourcesExecution copyOf()
356		{
357	0	MavenResourcesExecution mre = new MavenResourcesExecution();
358	0	mre.setAdditionalProperties( mre.getAdditionalProperties() );
359	0	mre.setEncoding( mre.getEncoding() );
360	0	mre.setEscapedBackslashesInFilePath( mre.isEscapedBackslashesInFilePath() );
361	0	mre.setEscapeString( mre.getEscapeString() );
362	0	mre.setFileFilters( copyList( mre.getFileFilters() ) );
363	0	mre.setFilterWrappers( copyList( mre.getFilterWrappers() ) );
364	0	mre.setIncludeEmptyDirs( mre.isIncludeEmptyDirs() );
365	0	mre.setInjectProjectBuildFilters( mre.isInjectProjectBuildFilters() );
366	0	mre.setMavenProject( mre.getMavenProject() );
367	0	mre.setMavenSession( mre.getMavenSession() );
368	0	mre.setNonFilteredFileExtensions( copyList( mre.getNonFilteredFileExtensions() ) );
369	0	mre.setOutputDirectory( mre.getOutputDirectory() );
370	0	mre.setOverwrite( mre.isOverwrite() );
371	0	mre.setProjectStartExpressions( copyList( mre.getProjectStartExpressions() ) );
372	0	mre.setResources( copyList( mre.getResources() ) );
373	0	mre.setResourcesBaseDirectory( mre.getResourcesBaseDirectory() );
374	0	mre.setUseDefaultFilterWrappers( mre.isUseDefaultFilterWrappers() );
375	0	mre.setSupportMultiLineFiltering( mre.isSupportMultiLineFiltering() );
376	0	return mre;
377		}
378
379		private List copyList( List lst )
380		{
381	0	if ( lst == null )
382		{
383	0	return null;
384		}
385	0	else if ( lst.isEmpty() )
386		{
387	0	return new ArrayList();
388		}
389		else
390		{
391	0	return new ArrayList( lst );
392		}
393		}
394
395		public boolean isSupportMultiLineFiltering()
396		{
397	54	return supportMultiLineFiltering;
398		}
399
400		public void setSupportMultiLineFiltering( boolean supportMultiLineFiltering )
401		{
402	27	this.supportMultiLineFiltering = supportMultiLineFiltering;
403	27	}
404		}