Author: akarasulu Date: Sun Nov 7 15:15:56 2004 New Revision: 56875 Added: incubator/directory/ldap/trunk/common/src/java/org/apache/ldap/common/util/PropertiesUtils.java Modified: incubator/directory/ldap/trunk/common/src/java/org/apache/ldap/common/ldif/LdifParser.java incubator/directory/ldap/trunk/common/src/java/org/apache/ldap/common/ldif/LdifParserImpl.java Log: Changes ...
o added new utility file for managing properties o partially cleaned up LDIF parser wrt formating and exceptions thrown Modified: incubator/directory/ldap/trunk/common/src/java/org/apache/ldap/common/ldif/LdifParser.java ============================================================================== --- incubator/directory/ldap/trunk/common/src/java/org/apache/ldap/common/ldif/LdifParser.java (original) +++ incubator/directory/ldap/trunk/common/src/java/org/apache/ldap/common/ldif/LdifParser.java Sun Nov 7 15:15:56 2004 @@ -16,14 +16,9 @@ package org.apache.ldap.common.ldif ; -import java.text.ParseException ; - import javax.naming.NamingException ; import javax.naming.directory.Attributes ; -import org.apache.ldap.common.util.MultiMap; - - /** * Parses an ldif into a multimap or an JNDI Attributes instance of attribute @@ -35,55 +30,32 @@ * be accessed and removed from the MultiMap or Attributes instance if need be * according to the specific context in which this parser is used. * - * @author <a href="mailto:[EMAIL PROTECTED]">Alex Karasulu</a> - * @author $Author: akarasulu $ - * @version $Revision: 1.7 $ + * @author <a href="mailto:[EMAIL PROTECTED]">Apache Directory Project</a> + * @version $Rev$ */ public interface LdifParser { /** * Parses an String representing an entry in LDAP Data Interchange Format - * (LDIF) storing its name and attributes in the supplied MultiMap instance. - * - * @param a_mmap the MultiMap instance to populate with LDIF attributes - * including the DN of the entry represented by the LDIF. - * @param an_ldif the entry in LDAP Data Interchange Format - * @deprecated - * @throws ParseException if the LDIF is malformed - * @throws NamingException if a naming exception results while the LDIF is - * being parsed - * TODO investigate if we need to throw a NamingException here - */ - void parse( MultiMap a_mmap, String an_ldif ) - throws ParseException, NamingException ; - - /** - * Parses an String representing an entry in LDAP Data Interchange Format * (LDIF) storing its attributes in the supplied Attributes instance. * - * @param an_attributes the Attributes instance to populate with LDIF + * @param attributes the Attributes instance to populate with LDIF * attributes including the DN of the entry represented by the LDIF. - * @param an_ldif the entry in LDAP Data Interchange Format - * @throws ParseException if the LDIF is malformed + * @param ldif the entry in LDAP Data Interchange Format * @throws NamingException if a naming exception results while the LDIF is * being parsed - * TODO investigate if we need to throw a NamingException here */ - void parse( Attributes an_attributes, String an_ldif ) - throws ParseException, NamingException ; + void parse( Attributes attributes, String ldif ) throws NamingException ; /** * Parses an LDIF into a special LdifEntry structure that tracks control * attributes within an LDIF. * - * @param an_ldif the LDIF to parse + * @param ldif the LDIF to parse * @return the LdifEntry parsed - * @throws ParseException if the LDIF is malformed * @throws NamingException if a naming exception results while the LDIF is * being parsed - * TODO investigate if we need to throw a NamingException here */ - LdifEntry parse( String an_ldif ) - throws ParseException, NamingException ; + LdifEntry parse( String ldif ) throws NamingException ; } Modified: incubator/directory/ldap/trunk/common/src/java/org/apache/ldap/common/ldif/LdifParserImpl.java ============================================================================== --- incubator/directory/ldap/trunk/common/src/java/org/apache/ldap/common/ldif/LdifParserImpl.java (original) +++ incubator/directory/ldap/trunk/common/src/java/org/apache/ldap/common/ldif/LdifParserImpl.java Sun Nov 7 15:15:56 2004 @@ -13,21 +13,35 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package org.apache.ldap.common.ldif ; - +/* + * Copyright 2001-2004 The Apache Software Foundation. + * + * 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 org.apache.ldap.common.ldif; -import java.text.ParseException ; -import java.io.IOException ; -import java.io.StringReader ; -import java.io.BufferedReader ; +import java.io.IOException; +import java.io.StringReader; +import java.io.BufferedReader; -import javax.naming.NamingException ; -import javax.naming.directory.Attributes ; -import javax.naming.directory.DirContext ; +import javax.naming.NamingException; +import javax.naming.directory.Attributes; +import javax.naming.directory.DirContext; -import org.apache.ldap.common.util.Base64 ; -import org.apache.ldap.common.util.MultiMap; +import org.apache.ldap.common.util.Base64; +import org.apache.ldap.common.message.ResultCodeEnum; +import org.apache.eve.exception.EveNamingException; /** @@ -38,108 +52,22 @@ * Attributes instance. Until they are the populated container cannot be deemed * representative of an entry. * - * @task Get the RFC for LDIF syntax in this javadoc. + * @todo Get the RFC for LDIF syntax in this javadoc. * @see <a href="http://www.faqs.org/rfcs/rfc2849.html";> RFC 2849 </a> - * @author <a href="mailto:[EMAIL PROTECTED]">Alex Karasulu</a> - * @author $Author: jmachols $ - * @version $Revision: 1.12 $ + * @author <a href="mailto:[EMAIL PROTECTED]">Apache Directory Project</a> + * @version $Rev$ */ -public class LdifParserImpl - implements LdifParser +public class LdifParserImpl implements LdifParser { /** - * Parses an LDIF String populating a multimap with both single valued and - * multivalued attributes. - * - * @param a_attrHash the hash of attributes to values. - * @param an_ldif the LDIF as a String. - * @deprecated - * @throws ParseException if an_ldif violates LDIF syntax. - */ - public void parse( MultiMap a_attrHash, String an_ldif ) - throws ParseException - { - boolean l_isBase64Encoded = false ; - int l_lineCount = 0 ; - int l_index ; - String l_line ; - String l_attrName ; - String l_attrValue ; - StringReader l_strIn = new StringReader( an_ldif ) ; - BufferedReader l_in = new BufferedReader( l_strIn ) ; - - try - { - while ( ( l_line = l_in.readLine() ) != null ) - { - // Try to advance to ':' if one exists. - if ( ( l_index = l_line.indexOf( ':' ) ) == -1 ) - { - throw new ParseException( "Line " + l_lineCount + " [" - + l_line + "] does not correspond to an LDIF entry " - + "attribute value pair.\n{" + an_ldif + "}", - l_lineCount ) ; - } - - // Capture data while at first colon. - l_attrName = l_line.substring( 0, l_index ).trim() ; - - // Consume next char and check if it's a colon for binary attr. - if ( l_line.charAt( ++l_index ) == ':' ) - { - l_isBase64Encoded = true ; - } - - // Advance index past whitespace to the first char of the value. - try - { - while ( l_line.charAt( ++l_index ) == ' ' ) - { - ; // Nothing - } - - // Capture attribute value from first char till end of line. - l_attrValue = l_line.substring( l_index ) ; - } - catch ( StringIndexOutOfBoundsException e ) - { - l_attrValue = "" ; - } - - /* - * We need to construct an attribute yet we may not know if it - * is single valued or multi valued. Our best bet is to just - * cover all possibilities using a basic attribute instance that - * the basic attrubutes instance creates automatically. - */ - if ( l_isBase64Encoded && ( l_attrValue != null ) ) - { - a_attrHash.put( l_attrName, base64decode( l_attrValue ) ) ; - l_isBase64Encoded = false ; - } - else - { - a_attrHash.put( l_attrName, l_attrValue ) ; - } - } - } - catch ( IOException e ) - { - // Does not really occur: we follow form by transforming w/ rethrow - throw new ParseException( e.getMessage(), l_lineCount ) ; - } - } - - - /** * Decodes an encoded string in base64 into a byte array. * - * @param a_attrValue the value of a encoded binary attribute. + * @param attrValue the value of a encoded binary attribute. * @return the decoded binary data as a byte array. */ - public byte [] base64decode( String a_attrValue ) + public byte [] base64decode( String attrValue ) { - return ( Base64.decode( a_attrValue.toCharArray() ) ) ; + return ( Base64.decode( attrValue.toCharArray() ) ); } @@ -147,60 +75,58 @@ * Parses an String representing an entry in LDAP Data Interchange Format * (LDIF) storing its attributes in the supplied Attributes instance. * - * @param an_attributes the attributes from the LDIF + * @param attributes the attributes from the LDIF * including the DN of the entry represented by the LDIF. - * @param an_ldif the entry in LDAP Data Interchange Format - * @throws ParseException if an_ldif violates LDIF syntax. - * @throws NamingException TODO doc me + * @param ldif the entry in LDAP Data Interchange Format + * @throws NamingException if there any failures while parsing the LDIF and + * populating the attirubutes */ - public void parse( Attributes an_attributes, String an_ldif ) - throws ParseException, NamingException + public void parse( Attributes attributes, String ldif ) throws NamingException { - boolean l_isBase64Encoded = false ; - int l_lineCount = 0 ; - int l_index ; - String l_line ; - String l_attrName ; - String l_attrValue ; - StringReader l_strIn = new StringReader( an_ldif ) ; - BufferedReader l_in = new BufferedReader( l_strIn ) ; + boolean isBase64Encoded = false; + int lineCount = 0; + int index; + String line; + String attrName; + String attrValue; + StringReader strIn = new StringReader( ldif ); + BufferedReader in = new BufferedReader( strIn ); try { - while ( ( l_line = l_in.readLine() ) != null ) + while ( ( line = in.readLine() ) != null ) { // Try to advance to ':' if one exists. - if ( ( l_index = l_line.indexOf( ':' ) ) == -1 ) + if ( ( index = line.indexOf( ':' ) ) == -1 ) { - throw new ParseException( "Line " + l_lineCount + " [" - + l_line + "] does not correspond to an LDIF entry " - + "attribute value pair.\n{" + an_ldif + "}", - l_lineCount ) ; + throw new EveNamingException( "Line " + lineCount + " [" + + line + "] does not correspond to an LDIF entry " + + "attribute value pair.\n{" + ldif + "}", + ResultCodeEnum.OTHER ); } // Capture data while at first colon. - l_attrName = l_line.substring( 0, l_index ).trim() ; + attrName = line.substring( 0, index ).trim(); // Consume next char and check if it's a colon for binary attr. - if ( l_line.charAt( ++l_index ) == ':' ) + if ( line.charAt( ++index ) == ':' ) { - l_isBase64Encoded = true ; + isBase64Encoded = true; } // Advance index past whitespace to the first char of the value. try { - while ( l_line.charAt( ++l_index ) == ' ' ) - { - ; // Does nothing! + while ( line.charAt( ++index ) == ' ' ) + {; // Does nothing! } // Capture attribute value from first char till end of line. - l_attrValue = l_line.substring( l_index ) ; + attrValue = line.substring( index ); } catch ( StringIndexOutOfBoundsException e ) { - l_attrValue = "" ; + attrValue = ""; } /* @@ -209,22 +135,21 @@ * cover all possibilities using a basic attribute instance that * the basic attrubutes instance creates automatically. */ - if ( l_isBase64Encoded && ( l_attrValue != null ) ) + if ( isBase64Encoded && ( attrValue != null ) ) { - an_attributes.put( l_attrName, - base64decode( l_attrValue ) ) ; - l_isBase64Encoded = false ; + attributes.put( attrName, base64decode( attrValue ) ); + isBase64Encoded = false; } else { - an_attributes.put( l_attrName, l_attrValue ) ; + attributes.put( attrName, attrValue ); } } } catch ( IOException e ) { // Does not really occur: we follow form by transforming w/ rethrow - throw new ParseException( e.getMessage(), l_lineCount ) ; + throw new EveNamingException( ResultCodeEnum.OTHER ); } } @@ -235,23 +160,23 @@ * * @param an_ldif the entry in LDAP Data Interchange Format * @return the LdifEntry parsed from the LDIF string - * @throws ParseException if an_ldif violates LDIF syntax - * @throws NamingException TODO document me + * @throws NamingException if there any failures while parsing the LDIF and + * populating the attirubutes */ public LdifEntry parse( String an_ldif ) - throws ParseException, NamingException + throws NamingException { - boolean l_isBase64Encoded = false ; - int l_lineCount = 0 ; - int l_index ; - String l_line ; - String l_attrName = new String () ; - String l_attrValue = new String () ; - String l_prevAttrValue = null ; - StringReader l_strIn = new StringReader( an_ldif ) ; - BufferedReader l_in = new BufferedReader( l_strIn ) ; - LdifEntry l_entry = new LdifEntry() ; - int l_currentModOp = -1 ; + boolean l_isBase64Encoded = false; + int l_lineCount = 0; + int l_index; + String l_line; + String l_attrName = new String (); + String l_attrValue = new String (); + String l_prevAttrValue = null; + StringReader l_strIn = new StringReader( an_ldif ); + BufferedReader l_in = new BufferedReader( l_strIn ); + LdifEntry l_entry = new LdifEntry(); + int l_currentModOp = -1; try { @@ -265,20 +190,21 @@ { if ( l_currentModOp == -1 ) { - throw new ParseException( "A modification" + throw new EveNamingException( "A modification" + " type must be supplied for a change " - + "type of modify", l_lineCount ) ; + + "type of modify", + ResultCodeEnum.OTHER ); } l_entry.addModificationItem( l_currentModOp, - l_attrName, l_attrValue ) ; + l_attrName, l_attrValue ); } else { if ( l_isBase64Encoded && ( l_attrValue != null ) ) { l_entry.addAttribute( l_attrName, - base64decode( l_attrValue ) ) ; - l_isBase64Encoded = false ; + base64decode( l_attrValue ) ); + l_isBase64Encoded = false; } else { @@ -286,27 +212,26 @@ } } } - l_currentModOp = -1 ; - l_prevAttrValue = null ; - continue ; + l_currentModOp = -1; + l_prevAttrValue = null; + continue; } // Try to advance to ':' if one exists. if ( ( l_index = l_line.indexOf( ':' ) ) == -1 ) { - throw new ParseException( "Line " + l_lineCount + " [" + throw new EveNamingException( "Line " + l_lineCount + " [" + l_line + "] does not correspond to an LDIF entry " + "attribute value pair.\n{" + an_ldif + "}", - l_lineCount ) ; - + ResultCodeEnum.OTHER ); } // Capture data while at first colon. - l_attrName = l_line.substring( 0, l_index ).trim() ; + l_attrName = l_line.substring( 0, l_index ).trim(); // Consume next char and check if it's a colon for binary attr. if ( l_line.charAt( ++l_index ) == ':' ) { - l_isBase64Encoded = true ; + l_isBase64Encoded = true; } // Advance index past whitespace to the first char of the value. @@ -314,15 +239,15 @@ { while ( l_line.charAt( ++l_index ) == ' ' ) { - ; // Does nothing! + ; // Does nothing! } // Capture attribute value from first char till end of line. - l_attrValue = l_line.substring( l_index ) ; + l_attrValue = l_line.substring( l_index ); } catch ( StringIndexOutOfBoundsException e ) { - l_attrValue = "" ; + l_attrValue = ""; } /* @@ -331,55 +256,58 @@ */ if ( l_attrName.equalsIgnoreCase( "dn" ) ) { - l_entry.setDn( l_attrValue ) ; + l_entry.setDn( l_attrValue ); } else if ( l_attrName.equalsIgnoreCase( "version" ) ) { - l_entry.setVersion( Integer.parseInt( l_attrValue ) ) ; + l_entry.setVersion( Integer.parseInt( l_attrValue ) ); } else if ( l_attrName.equalsIgnoreCase( "control" ) ) { - ; // Not implemented + ; // Not implemented } else if ( l_attrName.equalsIgnoreCase( "changetype" ) ) { - l_entry.setModType( l_attrValue ) ; + l_entry.setModType( l_attrValue ); } else if ( l_attrName.equalsIgnoreCase( "add" ) ) { if ( !l_entry.getModType().equalsIgnoreCase( "modify" ) ) { - throw new ParseException( "Cannot use modification " + throw new EveNamingException( "Cannot use modification " + l_attrName + " identifier on " + l_entry.getModType() - + " change type", l_lineCount ) ; + + " change type", + ResultCodeEnum.OTHER ); } - l_currentModOp = DirContext.ADD_ATTRIBUTE ; + l_currentModOp = DirContext.ADD_ATTRIBUTE ; } else if ( l_attrName.equalsIgnoreCase( "replace" ) ) { if ( !l_entry.getModType().equalsIgnoreCase( "modify" ) ) { - throw new ParseException( "Cannot use modification " + throw new EveNamingException( "Cannot use modification " + l_attrName + " identifier on " + l_entry.getModType() - + " change type", l_lineCount ) ; + + " change type", + ResultCodeEnum.OTHER ); } - l_currentModOp = DirContext.REPLACE_ATTRIBUTE ; + l_currentModOp = DirContext.REPLACE_ATTRIBUTE; } else if ( l_attrName.equalsIgnoreCase( "delete" ) ) { if ( !l_entry.getModType().equalsIgnoreCase( "modify" ) ) { - throw new ParseException( "Cannot use modification " + throw new EveNamingException( "Cannot use modification " + l_attrName + " identifier on " + l_entry.getModType() - + " change type", l_lineCount ) ; + + " change type", + ResultCodeEnum.OTHER ); } - l_currentModOp = DirContext.REMOVE_ATTRIBUTE ; + l_currentModOp = DirContext.REMOVE_ATTRIBUTE; if ( l_attrValue != null ) { - l_prevAttrValue = l_attrValue ; + l_prevAttrValue = l_attrValue; } } else @@ -388,34 +316,34 @@ { if ( l_currentModOp == -1 ) { - throw new ParseException( "A modification type must" + throw new EveNamingException( "A modification type must" + " be supplied for a change type of modify", - l_lineCount ) ; + ResultCodeEnum.OTHER ); } l_entry.addModificationItem( l_currentModOp, l_attrName, - l_attrValue ) ; + l_attrValue ); } else { if ( l_isBase64Encoded && ( l_attrValue != null ) ) { l_entry.addAttribute( l_attrName, - base64decode( l_attrValue ) ) ; - l_isBase64Encoded = false ; + base64decode( l_attrValue ) ); + l_isBase64Encoded = false; } else { - l_entry.addAttribute( l_attrName, l_attrValue ) ; + l_entry.addAttribute( l_attrName, l_attrValue ); } } } } - return l_entry ; + return l_entry; } catch ( IOException e ) { // Does not really occur: we follow form by transforming w/ rethrow - throw new ParseException( e.getMessage(), l_lineCount ) ; + throw new EveNamingException( e.getMessage(), ResultCodeEnum.OTHER ); } } } Added: incubator/directory/ldap/trunk/common/src/java/org/apache/ldap/common/util/PropertiesUtils.java ============================================================================== --- (empty file) +++ incubator/directory/ldap/trunk/common/src/java/org/apache/ldap/common/util/PropertiesUtils.java Sun Nov 7 15:15:56 2004 @@ -0,0 +1,608 @@ +/* + * Copyright 2004 The Apache Software Foundation + * + * 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 org.apache.ldap.common.util; + + +import java.util.*; + +import java.io.File; +import java.io.InputStream; +import java.io.IOException; +import java.io.FileInputStream; + +import javax.naming.directory.Attributes; +import javax.naming.NamingException; + +import org.apache.ldap.common.NotImplementedException; +import org.apache.ldap.common.ldif.LdifParserImpl; +import org.apache.ldap.common.message.LockableAttributesImpl; + + +/** + * A utility class used for accessing, finding, merging and macro expanding + * properties, on disk, via URLS or as resources. + * + * @author <a href="mailto:[EMAIL PROTECTED]">Apache Directory Project</a> + * @version $Rev$ + */ +public class PropertiesUtils +{ + /** default properties file extension */ + private static final String DOTPROPERTIES = ".properties"; + + + // ------------------------------------------------------------------------ + // Utilities for discovering Properties + // ------------------------------------------------------------------------ + + + /** + * Loads a properties object in a properties file if it exists relative to + * the filename ${user.home}. If the file ${user.home}/[filename] does not + * exist then one last attempt to find the file is made if filename does not + * have a .properties extension. If so and ${user.home}/[filename].properties + * exists then it is loaded. + * + * @param filename the properties file name with or without an extension + * @return the user properties object + */ + public static Properties findUserProperties( String filename ) + { + return findProperties( new File( System.getProperty( "user.home" ) ), filename ) ; + } + + + /** + * Create a new properties object and load the properties file if it exists + * relative to [dir]/[filename] or [dir]/[filename].properties. + * + * @param dir the base directory + * @param filename the full fine name or the base name w/o the extension + * @return the loaded properties object + */ + public static Properties findProperties( File dir, String filename ) + { + final File asis = new File( dir, filename ); + + if ( asis.exists() ) + { + return getProperties( asis ); + } + + if ( filename.endsWith( DOTPROPERTIES ) ) + { + String noExt = filename.substring( 0, filename.length() - 11 ); + if ( new File( dir, noExt).exists() ) + { + return getProperties( new File( dir, noExt) ); + } + + return new Properties(); + } + + File withExt = new File( dir, filename + DOTPROPERTIES ); + if ( withExt.exists() ) + { + return getProperties( withExt ); + } + + return new Properties(); + } + + + /** + * Load a properties from a resource relative to a supplied class. First + * an attempt is made to locate a property file colocated with the class + * with the name [class].properties. If this cannot be found or errors + * result an empty Properties file is returned. + * + * @param ref a class to use for relative path references + * @return the static properties + */ + public static Properties getStaticProperties( Class ref ) + { + final Properties properties = new Properties(); + final String address = ref.toString().replace( '.','/' ); + final String path = address + ".properties"; + InputStream input = ref.getResourceAsStream( path ); + + if( null != input ) + { + try + { + properties.load( input ); + } + catch ( IOException e ) + { + return properties; + } + } + + return properties; + } + + + /** + * Load properties from a resource relative to a supplied class and path. + * + * @param ref a class to use for relative path references + * @param path the relative path to the resoruce + * @return the static properties + */ + public static Properties getStaticProperties( Class ref, String path ) + { + Properties properties = new Properties(); + InputStream input = ref.getResourceAsStream( path ); + + if( input == null ) + { + return properties; + } + + try + { + properties.load( input ); + } + catch ( IOException e ) + { + return properties; + } + + return properties; + } + + + /** + * Creates a properties object and loads the properties in the file otherwise + * and empty property object will be returned. + * + * @param file the properties file + * @return the properties object + */ + public static Properties getProperties( File file ) + { + Properties properties = new Properties(); + + if( null == file ) + { + return properties; + } + + if( file.exists() ) + { + try + { + properties.load( new FileInputStream( file ) ); + } + catch ( IOException e ) + { + return properties; + } + } + + return properties; + } + + + /** + * Loads a properties file as a CL resource if it exists and returns an + * empty Properties object otherwise. + * + * @param classloader the loader to use for the resources + * @param path the path to the resource + * @return the loaded or new Properties + */ + public static Properties getProperties( ClassLoader classloader, String path ) + { + Properties properties = new Properties(); + InputStream input = classloader.getResourceAsStream( path ); + + if( input != null ) + { + try + { + properties.load( input ); + } + catch ( IOException e ) + { + return properties; + } + } + + return properties; + } + + + /** + * Loads a properties file as a class resource if it exists and returns an + * empty Properties object otherwise. + * + * @param clazz the class to use for resolving the resources + * @param path the relative path to the resource + * @return the loaded or new Properties + */ + public static Properties getProperties( Class clazz, String path ) + { + Properties properties = new Properties(); + InputStream input = clazz.getResourceAsStream( path ); + + if( input != null ) + { + try + { + properties.load( input ); + } + catch ( IOException e ) + { + return properties; + } + } + + return properties; + } + + + // ------------------------------------------------------------------------ + // Utilities for operating on or setting Properties values + // ------------------------------------------------------------------------ + + + /** + * Expands out a set of property key macros in the following format + * ${foo.bar} where foo.bar is a property key, by dereferencing the value + * of the key using the original source Properties and other optional + * Properties. + * + * If the original expanded Properties contain the value for the macro key, + * foo.bar, then dereferencing stops by using the value in the expanded + * Properties: the other optional Properties are NOT used at all. + * + * If the original expanded Properties do NOT contain the value for the + * macro key, then the optional Properties are used in order. The first of + * the optionals to contain the value for the macro key (foo.bar) shorts the + * search. Hence the first optional Properties in the array to contain a + * value for the macro key (foo.bar) is used to set the expanded value. + * + * If a macro cannot be expanded because it's key was not defined within the + * expanded Properties or one of the optional Properties then it is left as + * is. + * + * @param expanded the Properties to perform the macro expansion upon + * @param optionals null or an optional set of Properties to use for + * dereferencing macro keys (foo.bar) + */ + public static void macroExpand( Properties expanded, Properties [] optionals ) + { + // Handle null optionals + if ( null == optionals ) + { + optionals = new Properties [ 0 ]; + } + + Enumeration list = expanded.propertyNames(); + while ( list.hasMoreElements() ) + { + String key = ( String ) list.nextElement(); + String macro = expanded.getProperty( key ); + + int n = macro.indexOf( "${" ); + if( n < 0 ) + { + continue; + } + + int m = macro.indexOf( "}", n+2 ); + if( m < 0 ) + { + continue; + } + + final String symbol = macro.substring( n+2, m ); + + if ( expanded.containsKey( symbol ) ) + { + final String value = expanded.getProperty( symbol ); + final String head = macro.substring( 0, n ); + final String tail = macro.substring( m+1 ); + final String resolved = head + value + tail; + expanded.put( key, resolved ); + continue; + } + + /* + * Check if the macro key exists within the array of optional + * Properties. Set expanded value to first Properties with the + * key and break out of the loop. + */ + for ( int ii = 0; ii < optionals.length; ii++ ) + { + if ( optionals[ii].containsKey( symbol ) ) + { + final String value = optionals[ii].getProperty( symbol ); + final String head = macro.substring( 0, n ); + final String tail = macro.substring( m+1 ); + final String resolved = head + value + tail; + expanded.put( key, resolved ); + break; + } + } + } + } + + + /** + * Discovers a value within a set of Properties either halting on the first + * time the property is discovered or continuing on to take the last value + * found for the property key. + * + * @param key a property key + * @param sources a set of source Properties + * @param haltOnDiscovery true if we stop on finding a value, false + * otherwise + * @return the value found or null + */ + public static String discover( String key, Properties[] sources, boolean haltOnDiscovery ) + { + String retval = null; + + for( int ii = 0; ii < sources.length; ii++ ) + { + if ( sources[ii].containsKey( key ) ) + { + retval = sources[ii].getProperty( key ); + + if ( haltOnDiscovery ) + { + break; + } + } + } + + return retval; + } + + + /** + * Merges a set of properties from source Properties into a target + * properties instance containing keys. This method does not allow null + * overrides. + * + * @param keys the keys to discover values for + * @param sources the sources to search + * @param haltOnDiscovery true to halt on first find or false to continue + * to last find + */ + public static void discover( Properties keys, Properties[] sources, boolean haltOnDiscovery ) + { + if ( null == sources || null == keys ) { return; } + + /* + * H A N D L E S I N G L E V A L U E D K E Y S + */ + Iterator list = keys.keySet().iterator(); + while ( list.hasNext() ) + { + String key = ( String ) list.next(); + String value = discover( key, sources, haltOnDiscovery ); + + if ( value != null ) + { + keys.setProperty( key, value ); + } + } + } + + + // ------------------------------------------------------------------------ + // Various Property Accessors + // ------------------------------------------------------------------------ + + /** + * Gets a String property as a boolean returning a defualt if the key is + * not present. In any case, true, on, 1 and yes strings return true and + * everything else returns + * + * @param props the properties to get the value from + * @param key the property key + * @param defaultValue the default value to return if key is not present + * @return true defaultValue if property does not exist, else return true + * if the String value is one of 'true', 'on', '1', 'yes', otherwise false + * is returned + */ + public static boolean get( Properties props, String key, boolean defaultValue ) + { + if ( props == null || ! props.containsKey( key ) || props.getProperty( key ) == null ) + { + return defaultValue; + } + + String val = props.getProperty( key ).trim().toLowerCase(); + return val.equals( "true" ) || val.equals( "on" ) || val.equals( "1" ) || val.equals( "yes" ); + } + + + public static int get( Properties props, String key, int defaultValue ) + { + if ( props == null || ! props.containsKey( key ) || props.getProperty( key ) == null ) + { + return defaultValue; + } + + throw new NotImplementedException(); + } + + + public static long get( Properties props, String key, long defaultValue ) + { + if ( props == null || ! props.containsKey( key ) || props.getProperty( key ) == null ) + { + return defaultValue; + } + + throw new NotImplementedException(); + } + + + public static byte get( Properties props, String key, byte defaultValue ) + { + if ( props == null || ! props.containsKey( key ) || props.getProperty( key ) == null ) + { + return defaultValue; + } + + throw new NotImplementedException(); + } + + + public static char get( Properties props, String key, char defaultValue ) + { + if ( props == null || ! props.containsKey( key ) || props.getProperty( key ) == null ) + { + return defaultValue; + } + + throw new NotImplementedException(); + } + + + /** + * Fills a set with the space delimited values of a property. If values is + * null a new Set is created and returned. + * + * @param props the properties to get the property values from + * @param key the key of the multivalued property + * @param values the values to populate + * @return the values set so it can be filled then used + */ + public static Set fill( Properties props, String key, Set values ) + { + if ( values == null ) { values = new HashSet(); } + return ( Set ) fillCollection( props, key, values, " " ); + } + + + /** + * Fills a set with the delimited values of a property. If values is + * null a new Set is created and returned. + * + * @param props the properties to get the property values from + * @param key the key of the multivalued property + * @param values the values to populate + * @param delimiter the delimiter string to split the property with + * @return the values set so it can be filled then used + */ + public static Set fill( Properties props, String key, Set values, String delimiter ) + { + if ( values == null ) { values = new HashSet(); } + return ( Set ) fillCollection( props, key, values, delimiter ); + } + + + /** + * Fills a list with the space delimited values of a property. The list + * maintains the order of values in the multivalued property. If values is + * null a new List is created and returned. + * + * @param props the properties to get the property values from + * @param key the key of the multivalued property + * @param values the values to populate + * @return the values list so it can be filled then used + */ + public static List fill( Properties props, String key, List values ) + { + if ( values == null ) { values = new ArrayList(); } + return ( List ) fillCollection( props, key, values, " " ); + } + + + /** + * Fills a list with the space delimited values of a property. The list + * maintains the order of values in the multivalued property. If values is + * null a new List is created and returned. + * + * @param props the properties to get the property values from + * @param key the key of the multivalued property + * @param values the values to populate + * @param delimiter the delimiter string to split the property with + * @return the values list so it can be filled then used + */ + public static List fill( Properties props, String key, List values, String delimiter ) + { + if ( values == null ) { values = new ArrayList(); } + return ( List ) fillCollection( props, key, values, delimiter ); + } + + + /** + * Fills a collection with the delimited values of a property. + * + * @param props the properties to get the property values from + * @param key the key of the multivalued property + * @param values the values to populate + * @param delimiter the delimiter string to split the property with + * @return the values collection so it can be filled then used + */ + public static Collection fillCollection( Properties props, String key, Collection values, String delimiter ) + { + if ( props == null || ! props.containsKey( key ) || props.getProperty( key ) == null ) + { + return values; + } + + String[] items = props.getProperty( key ).trim().split( delimiter ); + for ( int ii = 0; ii < items.length; ii++ ) + { + values.add( items[ii] ); + } + + return values; + } + + + /** + * Creates, fills and returns an Attributes instance using the LDIF encoded + * within the property value. The LDIF should use '*' (asterisk) characters + * as line delimiters within the property value. These are replaced with + * newlines and fed to the LDIF parser. Also note that the LdifParser + * deposites the DN as a property within the attributes object. + * + * @param props the properties to get the ldif property from + * @param key the key for the LDIF property + * @return the attributes for the encoded LDIF entry + */ + public static Attributes fillAttributes( Properties props, String key, Attributes values ) throws NamingException + { + if ( props == null || ! props.containsKey( key ) || props.getProperty( key ) == null ) + { + if ( values == null ) + { + return new LockableAttributesImpl(); + } + + return values; + } + + if ( values == null ) + { + values = new LockableAttributesImpl(); + } + + String ldif = props.getProperty( key ).trim().replace( '*', '\n' ); + ( new LdifParserImpl() ).parse( values, ldif ); + return values; + } +}
