jpos.config.simple.SimpleEntry Maven / Gradle / Ivy
package jpos.config.simple;
///////////////////////////////////////////////////////////////////////////////
//
// This software is provided "AS IS". The JavaPOS working group (including
// each of the Corporate members, contributors and individuals) MAKES NO
// REPRESENTATIONS OR WARRANTIES ABOUT THE SUITABILITY OF THE SOFTWARE,
// EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED
// WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
// NON-INFRINGEMENT. The JavaPOS working group shall not be liable for
// any damages suffered as a result of using, modifying or distributing this
// software or its derivatives. Permission to use, copy, modify, and distribute
// the software and its documentation for any purpose is hereby granted.
//
// The JavaPOS Config/Loader (aka JCL) is now under the CPL license, which
// is an OSS Apache-like license. The complete license is located at:
// http://www.ibm.com/developerworks/library/os-cpl.html
//
///////////////////////////////////////////////////////////////////////////////
import jpos.config.JposEntry;
import java.util.*;
import java.io.Serializable;
import jpos.config.*;
import jpos.util.JposEntryUtility;
/**
* This is a simple implementation of the JposEntry interface using a Hashtable
* to collect the properties
* @since 0.1 (Philly 99 meeting)
* @author E. Michael Maximilien ([email protected])
*/
public class SimpleEntry implements JposEntry, Serializable, Comparable
{
//--------------------------------------------------------------------------
// Ctor(s)
//
/**
* Default ctor (sets the JposRegPopulator to null)
* @since 1.3 (Washington DC 2001 meeting)
*/
public SimpleEntry() { regPopulator = null; }
/**
* One argument ctor taking the JposRegPopulator for this entry
* @param populator the JposRegPopulator for this entry
* @since 1.3 (Washington DC 2001 meeting)
*/
public SimpleEntry( JposRegPopulator populator ) { regPopulator = populator; }
/**
* One argument ctor taking the JposRegPopulator for this entry
* @param logicalName the logical name for this entry
* @param populator the JposRegPopulator for this entry
* @since 1.3 (Washington DC 2001 meeting)
*/
public SimpleEntry( String logicalName, JposRegPopulator populator )
{
this( populator );
addProperty( LOGICAL_NAME_PROP_NAME, logicalName );
}
/**
* One argument ctor taking the LogicalName this entry
* @param logicalName the logical name string for this entry
* @since 2.0.0
*/
SimpleEntry( String logicalName ) { addProperty( LOGICAL_NAME_PROP_NAME, logicalName ); }
//--------------------------------------------------------------------------
// Public instance methods
//
/**
* @return count of number of properties
* @since 0.1 (Philly 99 meeting)
*/
public int getPropertyCount() { return properties.size(); }
/**
* @return an enumerator for the properties names
* @since 0.1 (Philly 99 meeting)
*/
public Enumeration getPropertyNames() { return properties.keys(); }
/**
* @return true if there is a property by the name specified
* @param propName the property name String
* @since 0.1 (Philly 99 meeting)
*/
public boolean hasPropertyWithName( String propName ) { return properties.containsKey( propName ); }
/**
* @return true if there is a property by the value specified
* NOTE: Object.equals method will be used to compare
* @param propValue the property's value Object
* @since 0.1 (Philly 99 meeting)
*/
public boolean hasPropertyWithValue( Object propValue ) { return properties.contains( propValue ); }
/**
* @return the property's value Object
* @param propName the property's propName String
* @since 0.1 (Philly 99 meeting)
*/
public Object getPropertyValue( String propName ) { return properties.get( propName ); }
/**
* @return the property's type
* @param propName the property's name String
* @since 2.0.0
*/
public Class getPropertyType( String propName ) { return getPropertyValue( propName ).getClass(); }
/**
* Modifies the property value of the property passed
* @return the oldPropValue or null if this property does not exist
* @param propName the property name
* @param propValue the new property value
* @since 1.3 (Tokyo 2001 meeting)
* @throws java.lang.IllegalArgumentException if the propName or propValue is null
*/
public Object modifyPropertyValue( String propName, Object propValue ) throws IllegalArgumentException
{
checkNull( propName );
checkNull( propValue );
if( hasPropertyWithName( propName ) == false )
return null;
Object oldValue = removeProperty( propName );
addProperty( propName, propValue );
return oldValue;
}
/**
* Adds a property to the JposEntry object.
* NOTE: any property with the same name gets overlaid
* @param propName the name of this property (should be unique per property)
* @param propValue the properties value Object
* @since 0.1 (Philly 99 meeting)
* @throws java.lang.IllegalArgumentException if the propName or propValue is null
*/
public Object addProperty( String propName, Object propValue ) throws IllegalArgumentException
{
checkNull( propName );
checkNull( propValue );
return properties.put( propName, propValue );
}
/**
* Looks for a property with name specified and removes it. If none exist then
* does nothing and return null
* @return the value for the name passed
* @param propName the name String of the property to remove
* @since 0.1 (Philly 99 meeting)
*/
public Object removeProperty( String propName ) { return properties.remove( propName ); }
/**
* @return true if the two JposEntries have the same properties
* @since 0.1 (Philly 99 meeting)
*/
public boolean equals( JposEntry otherEntry )
{
if( otherEntry == null ) return false;
if( getPropertyCount() != otherEntry.getPropertyCount() ) return false;
Enumeration otherPropNames = otherEntry.getPropertyNames();
while( otherPropNames.hasMoreElements() )
{
String name = (String)otherPropNames.nextElement();
Object value = otherEntry.getPropertyValue( name );
if( !hasPropertyWithName( name ) ) return false;
if( !getPropertyValue( name ).equals( value ) ) return false;
}
return true;
}
/**
* @return a copy of this JposEntry object
* @since 1.3 (Tokyo 2001 meeting)
*/
public JposEntry copy()
{
JposEntry entryCopy = new SimpleEntry();
Enumeration entryNames = getPropertyNames();
while( entryNames.hasMoreElements() )
{
String propName = (String)entryNames.nextElement();
entryCopy.addProperty( propName,getPropertyValue( propName ) );
}
return entryCopy;
}
/**
* @return the JposRegPopulator that loads/saves this entry. If null the default
* populator is used
* @since 1.3 (Washington DC 2001 meeting)
*/
public JposRegPopulator getRegPopulator() { return regPopulator; }
/**
* @return the logical name for this JposEntry. This is a shortcut for easily getting
* the logical name vs getting a property and passing the logical name constant
* @see jpos.config.JposEntry#getPropertyValue
* @see jpos.config.JposEntry#LOGICAL_NAME_PROP_NAME
* @since 1.3 (Washington DC 2001 meeting)
*/
public String getLogicalName() { return (String)getPropertyValue( JposEntry.LOGICAL_NAME_PROP_NAME ); }
/**
* @return the JposEntry.Prop with name specified or null if no such property exist
* @param propName the property name
* @since 2.0.0
*/
public JposEntry.Prop getProp( String propName )
{
Object propValue = getPropertyValue( propName );
if( propValue == null ) return null;
return new Prop( propName, propValue );
}
/**
* @return an Iterator over the properties in this JposEntry as JposEntry.Prop objects
* @since 1.3 (Washington DC 2001)
*/
public Iterator getProps()
{
List list = new ArrayList();
Enumeration names = getPropertyNames();
while( names.hasMoreElements() )
{
String name = (String)names.nextElement();
list.add( new Prop( name, getPropertyValue( name ) ) );
}
return list.iterator();
}
/**
* Adds a new property
* @param prop the JposEntry.Prop to add
* @since 1.3 (Washington DC 2001 meeting)
* @throws java.lang.IllegalArgumentException if the argument is null
*/
public void add( JposEntry.Prop prop ) throws IllegalArgumentException
{
checkNull( prop );
addProperty( prop.getName(), prop.getValue() );
}
/**
* Removes the property
* @param prop the JposEntry.Prop to remove
* @since 1.3 (Washington DC 2001 meeting)
*/
public void remove( JposEntry.Prop prop ) { removeProperty( prop.getName() ); }
/**
* Modifies the property with name of property passed with the new value if
* that property currently exist in the entry otherwise does nothing
* @param prop the JposEntry.Prop to modify
* @since 2.0.0
* @throws java.lang.IllegalArgumentException if the prop is null
*/
public void modify( JposEntry.Prop prop ) throws IllegalArgumentException
{
checkNull( prop );
if( hasPropertyWithName( prop.getName() ) == false ) return;
modifyPropertyValue( prop.getName(), prop.getValue() );
}
/**
* @return true if this entry has the property passed
* @param prop the JposEntry.Prop to check for
* @since 1.3 (Washington DC 2001 meeting)
*/
public boolean hasProp( JposEntry.Prop prop ) { return hasPropertyWithName( prop.getName() ); }
/**
* @return a JposEntry.Prop object created with the tripplet
* passed as arguments
* @param propName the property name
* @param propValue the property value
* @param propType the property type (valid for this value)
* @throws jpos.config.JposConfigException if any of the argument is null or the
* property value and type mismatch or this is not a valid property type
* @see jpos.config.JposEntryConst#PROP_TYPES
* @since 2.0.0
*/
public JposEntry.Prop createProp( String propName, Object propValue, Class propType ) throws JposConfigException
{
if( propName == null || propValue == null || propType == null )
throw new JposConfigException( "Cannot create JposEntry.Prop with null argument" );
if( JposEntryUtility.validatePropValue( propValue, propType ) == false )
throw new JposConfigException( "Cannot create JposEntry.Prop with invalid value or type" );
return new Prop( propName, propValue );
}
//--------------------------------------------------------------------------
// Public overidden methods
//
/**
* @return true if the two JposEntries have the same properties
* @since 1.3 (SF 2K meeting)
*/
public boolean equals( Object object )
{
if( object instanceof JposEntry )
return equals( (JposEntry)object );
return false;
}
/**
* @return 0 if two entries are the same -1 if this is less or 1 of more than other
* the comparison for > and < uses the logicalName of the entry to decide
* @param otherEntry the other JposEntry
*/
public int compareTo( Object other )
{
if( other == null || ( (other instanceof JposEntry ) == false ) )
throw new RuntimeException( "Cannot compare: " + other + " with JposEntry: " + this );
JposEntry otherEntry = (JposEntry)other;
if( equals( otherEntry ) ) return 0;
return getLogicalName().compareTo( otherEntry.getLogicalName() );
}
/**
* @return a String representation of this entry
* @since 1.3 (SF 2K meeting)
*/
public String toString()
{
StringBuffer sb = new StringBuffer();
sb.append( "\n" );
sb.append( "\t \n" );
return sb.toString();
}
//--------------------------------------------------------------------------
// Package methods
//
/**
* Sets the JposRegPopulator that loads/saves this entry. If null the default
* populator is used
* @since 1.3 (Washington DC 2001 meeting)
*/
void setRegPopulator( JposRegPopulator populator ) { regPopulator = populator; }
//---------------------------------------------------------------------
// Class methods
//
/**
* Checks that the Object argument is not null and if it is throw a IllegalArgumentException
* @param object the Object argument
* @throws java.lang.IllegalArgumentException if the object is null
*/
protected static void checkNull( Object object ) throws IllegalArgumentException
{
if( object == null )
throw new IllegalArgumentException( "Invalid null argument passed for a JposEntry property value or name" );
}
//--------------------------------------------------------------------------
// Instance variables
//
private Hashtable properties = new Hashtable();
private transient JposRegPopulator regPopulator = null;
//-------------------------------------------------------------------------
// Inner classes
//
/**
* Inner class to represent a property of a JposEntry
* @author E. Michael Maximilien
* @since 1.3 (Washington DC 2001)
*/
public static class Prop implements JposEntry.Prop, Comparable
{
//---------------------------------------------------------------------
// Ctor(s)
//
/**
* Creates a JposEntry.Prop object
* @param name the name of this property
* @param value the value of this property
* @throws java.lang.IllegalArgumentException if any of the arguments are null
*/
public Prop( String name, Object value ) throws IllegalArgumentException
{
checkNull( name );
checkNull( value );
this.name = name;
this.value = value;
this.typeClass = value.getClass();
}
//---------------------------------------------------------------------
// Public methods
//
/** @return the name of this property */
public String getName() { return name; }
/** @return the value of this property (the value is returned as an Object) */
public Object getValue() { return value; }
/** @return the value of this property as a String */
public String getValueAsString() { return String.valueOf( value ); }
/**
* Returns the Class object that is the type of this property value
* possible values returned are the java.lang wrapper classes for the
* primitive types e.g. Integer, Byte, Boolean, ...
* @return the type of this property as a java.lang.Class object
*/
public Class getType() { return typeClass; }
/**
* Sets the name of this property
* @param s the String object
* @throws java.lang.IllegalArgumentException if the argument is null
*/
public void setName( String s ) throws IllegalArgumentException
{
checkNull( s );
name = s;
}
/**
* Sets the value of this property (String). Also sets its Type.
* This is the default type of any property
* @param objValue the object's value
* @throws java.lang.IllegalArgumentException if the value is null or
* that this is not a valid typed property value
*/
public void setValue( Object objValue ) throws IllegalArgumentException
{
checkNull( objValue );
if( JposEntryUtility.validatePropValue( objValue, objValue.getClass() ) == false )
throw new IllegalArgumentException( "Cannot set property named = " + getName() +
" with value = " + objValue +
" invalid value or type" );
setValue( objValue, objValue.getClass() );
}
/**
* @return true if the property is of the type specified by the Class
* object passed
* @param type the Class object
*/
public boolean isOfType( Class type )
{
if( type == null || typeClass == null ) return false;
return typeClass.equals( type );
}
/** @return a new copy of this JposEntry.Prop object */
public JposEntry.Prop copy() { return new SimpleEntry.Prop( getName(), getValue() ); }
//---------------------------------------------------------------------
// Public overridden
//
/**
* @return true if this and otherProp have same name and value
* @param otherProp the other JposEntry.Prop
*/
public boolean equals( Object otherProp )
{
if( otherProp == null ) return false;
if( !( otherProp instanceof JposEntry.Prop ) ) return false;
JposEntry.Prop prop = (JposEntry.Prop)otherProp;
return ( getName().equals( prop.getName() ) ) &&
( getValue().equals( prop.getValue() ) );
}
/**
* @return 0 if two entries are the same -1 if this is less or 1 of more than other
* the comparison for > and < uses the logicalName of the entry to decide
* @param otherEntry the other JposEntry
*/
public int compareTo( Object other )
{
if( other == null || ( (other instanceof JposEntry.Prop ) == false ) )
throw new RuntimeException( "Cannot compare: " + other + " with JposEntry.Prop: " + this );
JposEntry.Prop otherEntryProp = (JposEntry.Prop)other;
if( equals( otherEntryProp ) ) return 0;
return getName().compareTo( otherEntryProp.getName() );
}
/** @return a unique key for this object */
public int hashCode() { return getName().hashCode(); }
//---------------------------------------------------------------------
// Private methods
//
/**
* Sets the value of this property as an Object that must match the
* the type specified. Also sets its Type.
* @param object the Object value (must be one of wrapper for primitive types
* or java.lang.String)
* @param type the java.lang.Class object matching the object type
* @throws java.lang.IllegalArgumentException if the object value type does not
* match the Class type
*/
private void setValue( Object object, Class type ) throws IllegalArgumentException
{
checkNull( object );
checkNull( type );
if( !object.getClass().equals( type ) )
throw new IllegalArgumentException( "Value and value type not in agreement for property named = " + name );
value = object;
typeClass = type;
}
//---------------------------------------------------------------------
// Instance variables
//
private String name = "";
private Object value = null;
private Class typeClass = null;
}
//--------------------------------------------------------------------------
// Public constants
//
/**
* serialVersionUID constant to maintain serialization compatibility between releases
* @since 1.3 (SF 2K meeting)
*/
public static final long serialVersionUID = 6937048853319310114L;
}
© 2015 - 2024 Weber Informatics LLC | Privacy Policy