themeinstaller/source/src/com/nokia/tools/themeinstaller/localisation/FileSearch.java
/*
* Copyright (c) 2007 Nokia Corporation and/or its subsidiary(-ies).
* All rights reserved.
* This component and the accompanying materials are made available
* under the terms of "Eclipse Public License v1.0"
* which accompanies this distribution, and is available
* at the URL "http://www.eclipse.org/legal/epl-v10.html".
*
* Initial Contributors:
* Nokia Corporation - initial contribution.
*
* Contributors:
*
* Description: Searches files from given directories
*
*/
package com.nokia.tools.themeinstaller.localisation;
import java.io.File;
import java.io.FileFilter;
import java.util.Vector;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
/**
* Searches files that's name matches the regular expression.
* Search operations can be executed in one or multiple directories
* and also including subfolders in the search can activated.
*
* There are two versions for searching: recursive and non-recursive.
* Recursive version is used when flooding the search to subfolders
*/
public class FileSearch
{
private static Vector iFiles;
/**
* Find files in directories.
*
* @param aRootDirs The root directories where the search is initiated
* @param aFileNameExpression The file name expression
* @param aIncludeSubfolders Include subfolders in the search or not
* @param aAllowSameName Allow same filenames
*
* @return Found files in a vector
*/
public static Vector findFiles( Vector aRootDirs,
String aFileNameExpression, boolean aIncludeSubfolders,
boolean aAllowSame )
{
Vector allFiles = new Vector();
Vector fileFromOneSearch = new Vector();
for ( int i = 0; i < aRootDirs.size(); i++ )
{
fileFromOneSearch = findFiles( ( String ) aRootDirs.elementAt( i ),
aFileNameExpression, aIncludeSubfolders, aAllowSame );
for ( int j = 0; j < fileFromOneSearch.size(); j++ )
{
if ( aAllowSame && !allFiles.contains( fileFromOneSearch.get( j ) ) )
{
allFiles.add( fileFromOneSearch.get( j ) );
}
if ( !aAllowSame
&& !hasSameName( allFiles, ( File ) fileFromOneSearch.get( j ) ) )
{
allFiles.add( fileFromOneSearch.get( j ) );
}
}
}
return allFiles;
}
/**
* Find files in directories.
*
* @param aRootDirs The root directories where the search is initiated
* @param aFileNameExpression The file name expression
* @param aIncludeSubfolders Include subfolders in the search or not
*
* @return Found files in a vector
*/
public static Vector findFiles( Vector aRootDirs,
String aFileNameExpression, boolean aIncludeSubfolders )
{
return findFiles( aRootDirs, aFileNameExpression, aIncludeSubfolders,
true );
}
/**
* Find one file in directories. Returns the first one found.
*
* @param aRootDirs The root directories where the search is initiated
* @param aFileNameExpression The file name expression
* @param aIncludeSubfolders Include sub folders in the search or not
*
* @return Found file
*/
public static File findFile( Vector aRootDirs,
String aFileNameExpression, boolean aIncludeSubfolders )
{
Vector results = findFiles( aRootDirs, aFileNameExpression, aIncludeSubfolders,
true );
if( results.size() == 0 )
{
throw new IllegalArgumentException( "Localisation: File Search: " +
"File not found: " + aFileNameExpression );
}
return ( File ) results.elementAt( 0 );
}
/**
* Find files in directory.
*
* @param aRootDir The root directory where the search is initiated
* @param aFileNameExpression The file name expression
* @param aIncludeSubfolders Include subfolders in the search or not
* @param aAllowSameName Allow same filenames
*
* @return Found files in a vector
*/
public static Vector findFiles( String aRootDir,
String aFileNameExpression, boolean aIncludeSubfolders,
boolean aAllowSameName )
{
iFiles = new Vector();
// If subfolders included, use recursive version
if ( aIncludeSubfolders )
{
findFilesInSubfolder( new File( aRootDir ), aFileNameExpression,
aAllowSameName );
}
// If no subfolders included, use non-recursive version
if ( !aIncludeSubfolders )
{
findFilesInFolder( new File( aRootDir ), aFileNameExpression,
aAllowSameName );
}
return iFiles;
}
/**
* Find files in directory.
*
* @param aRootDir The root directory where the search is initiated
* @param aFileNameExpression The file name expression
* @param aIncludeSubfolders Include subfolders in the search or not
*
* @return Found files in a vector
*/
public static Vector findFiles( String aRootDir,
String aFileNameExpression, boolean aIncludeSubfolders )
{
return findFiles( aRootDir, aFileNameExpression, aIncludeSubfolders, true );
}
/**
* Find files in folder. Non-recursive version
*
* @param dir Directory to search in
* @param aFileNameExpression The file name expression
* @param aAllowSameName Allow same filename
*/
private static void findFilesInFolder( File dir,
final String aFileNameExpression, boolean aAllowSameName )
{
// Condition that file must fulfill
FileFilter fileFilter = new FileFilter()
{
public boolean accept( File file )
{
return ( !file.isDirectory() && match( aFileNameExpression,
file.getName() ) );
}
};
// Files that match the condition
File[] files = dir.listFiles( fileFilter );
for ( int i = 0; i < files.length; i++ )
{
if ( aAllowSameName )
{
iFiles.add( files[ i ] );
}
if ( !aAllowSameName && !hasSameName( iFiles, files[ i ] ) )
{
iFiles.add( files[ i ] );
}
}
}
/**
* Find files in folder and it's subfolder. Recursive version
*
* @param dir Root directory to start search
* @param aFileNameExpression the a file name expression
* @param aAllowSameName Allow same filenames
*/
private static void findFilesInSubfolder( File dir,
final String aFileNameExpression, boolean aAllowSameName )
{
// Flood the search to subdirectories:
if ( dir.isDirectory() )
{
File[] files = dir.listFiles();
for ( int i = 0; i < files.length; i++ )
{
findFilesInSubfolder( files[ i ], aFileNameExpression,
aAllowSameName );
}
}
// If not directory, add files that match conditions
else
{
if ( match( aFileNameExpression, dir.getName() ) )
{
if ( aAllowSameName )
{
iFiles.add( dir );
}
if ( !aAllowSameName && !hasSameName( iFiles, dir ) )
{
iFiles.add( dir );
}
}
}
}
/**
* Match regular expression with string.
*
* @param patternStr Regular expression for match
* @param input String to compare the regular expression
*
* @return true, if input matches the regular expression
*/
private static boolean match( String patternStr, CharSequence input )
{
Pattern pattern = Pattern.compile( patternStr );
Matcher matcher = pattern.matcher( input );
if ( matcher.matches() )
{
return true;
}
return false;
}
/**
* Checks if vector already has file with same name.
*
* @param aFiles Files to check
* @param aFile Reference file
*
* @return true, if vector already has file with same name
*/
private static boolean hasSameName( Vector aFiles, File aFile )
{
for ( int i = 0; i < aFiles.size(); i++ )
{
if ( ( ( File ) aFiles.get( i ) ).getName()
.equals( aFile.getName() ) )
{
return true;
}
}
return false;
}
}