Hi, gang!

Really hate to delay the final vote on this
not-so-vital issue. However it is only today
that my ideas got crystallized on the subject.

I by no means want to confront LSU. It's only
my perfectionism, want every idea to be polished
as ivory tower fragment :-)

Will you have a look at 4 alternative architectures
for mutationg configuration?

Can we complete the vote then -- I feel we will now
really have 5 options to choose from: the one from LSU
and 4 these I have put together from all I've learned
on Java development and software design patterns:

/**
 * @author Anton Tagunov
 */
interface Configuration{}

/**
 * This interface abstract the API for changing
 * a [EMAIL PROTECTED] #Configuration}.
 */
interface ConfigurationMutator
{
        void setValue( String value );
        void setValue( int value );
        void setValue( long value );
        void setValue( boolean value );
        void setValue( float value );
        void setValue( double value );
        
        void setAttribute( String name, String value );
        
        void setName( String name );
        
        /**
         * It is provisioned that many configuration
         * nodes will share the same <code>base</code>,
         * for instance fileName. However concatenating
         * <code>base</code> with <code>lineNo</code>
         * and <code>posNo</code> is allocating a new
         * String and is worth doing so only when this
         * information is about to be communicated to
         * user, for instance, if an exception has
         * occured.
         * 
         * @param base base name of configuration location,
         *     file name, url, jdbc uri, <code>null</code>
         *     if N/A
         * @param lineNo <code>-1</code> if N/A
         * @param posNo <code>-1</code> if N/A
         */
        void setLocation( String base, int lineNo, int posNo );
        
        void setNamespace( String namespace );
        void setPrefix( String prefix );
        
        /**
         * Create a child and insert it to position
         * <code>pos</code>
         */
        ConfigurationMutator createChild( int pos );
        
        void removeChild( int pos );
        
        /**
         * Each ConfigurationMutator has got an
         * instance of Configuration interface implementation
         * that it is closely tied with. This configuration
         * gives access to the data that ConfigurationMutator
         * changes. Their <code>getChildCount()</code>
         * methods always return the same value.
         * And the tree formed by getChild() invocations
         * exactly parallel each other.
         * 
         * <p>
         * The ConfigurationMutator and Configuration
         * interfaces are implemented with different
         * objects so that components which have been
         * given a Configuration instance wouldn't be
         * able to cast it to <code>MutableConfiguration</code>
         * 
         * @return our peer [EMAIL PROTECTED] #Configuration} instance.
         */
        Configuration getConfiguration();

        int getChildCount();

        ConfigurationMutator getChild( int i );
}

/**
 * ConfigurationMutator (see above) 
 * has got a slight drawback:
 * it doubles the number of objects that need to
 * be craeted: for each node we have a Configuration
 * and a ConfigurationMutator.
 * 
 * This class is an attempt to use "Builder" pattern
 * to overcome this drawback. There is only one
 * Builder per Configuration tree.
 * 
 * A builder instance may be used only to modify the
 * Configuration instances obtained from its own
 * [EMAIL PROTECTED] #getRoot} and [EMAIL PROTECTED] #createChild} methods.
 * 
 * This rule may be enforced for instance by
 * putting a reference to the builder into
 * each of the Configuration instances it
 * produces. Or an implementation my choose
 * not to enforce this limitation.
 * 
 * The clients should treat this limitation as being
 * enforced and never to violate it.
 * 
 * Alternative name: ModifiableConfigurationTree
 * 
 * @author Anton Tagunov
 */
interface ConfigurationBuilder
{
        void setValue( Configuration node, String value );
        void setValue( Configuration node, int value );
        void setValue( Configuration node, long value );
        void setValue( Configuration node, boolean value );
        void setValue( Configuration node, float value );
        void setValue( Configuration node, double value );
        
        void setAttribute( Configuration node, String name, String value );
        
        void setName( Configuration node, String name );
        void setLocation( Configuration node, String location );
        void setNamespace( Configuration node, String namespace );
        void setPrefix( Configuration node, String prefix );
        
        Configuration getRoot();
        
        Configuration createChild( Configuration node, int pos );
        
        void removeChild( Configuration node, int pos );
}

/**
 * Here's a third attempt at improving the mutable
 * configuration interface. DefaultConfiguration
 * interface is over-crowded. It is enough to
 * implement only basic functionality, utility
 * methods can do the rest w/o knowning a concrete
 * class.
 * 
 * This is an abridged version of MutableConfiguration
 * interface.
 * 
 * There is also a crucial difference in ideology
 * between ConfigurationMutator/ConfigurationBuilder
 * and MutableConfiguration[Abridged]:
 * 
 * the former (Builder/Mutator) enforce a homogenous
 * configuration hierarchy, it consists only of
 * instances of same class. And IMO this makes sense,
 * Configuration is mostly about storing information
 * in a tree. So it makes sense to provide a single
 * implementatino of the whole graph at once.
 * 
 * (The only subtlety is the getLocation() method, though,
 * you see the trick I've tried to use to overcome this
 * difficulty in Builder/Mutator.)
 * 
 * the present class allowes for heterogenous configuration
 * trees, clients now depend on some ConfigurationFactory
 * class to provide 'em configurations or on concrete
 * implementations
 * 
 * Also note that all of Builder/Mutator and
 * HomogenousMutableConfiguration (bellow) indirectly
 * enforce the rule that a Configuration node may
 * have noly one parent. This interface does not
 * (although implementation may do it).
 */
interface MutableConfigurationAbridged extends Configuration
{
        void setValue( String value );
        void setValue( int value );
        void setValue( long value );
        void setValue( boolean value );
        void setValue( float value );
        void setValue( double value );
        
        void setAttribute( String name, String value );
        
        void setName( String name );
        
        void setLocation( String base, int lineNo, int posNo );
        
        void setNamespace( String namespace );
        void setPrefix( String prefix );
        
        void addChild( int pos, MutableConfigurationAbridged child );
        void removeChild( int pos );
        
        boolean isReadOnly();
        void makeHierarchyReadOnly();
}

/**
 * Same as MutableConfigurationAbridged, but enforces homogeneity.
 * @author Anton Tagunov
 */
interface HomogenousMutableConfiguration extends Configuration
{
        void setValue( String value );
        void setValue( int value );
        void setValue( long value );
        void setValue( boolean value );
        void setValue( float value );
        void setValue( double value );
        
        void setAttribute( String name, String value );
        
        void setName( String name );
        
        void setLocation( String base, int lineNo, int posNo );
        
        void setNamespace( String namespace );
        void setPrefix( String prefix );
        
        HomogenousMutableConfiguration createChild( int pos );
        void removeChild( int pos );
        
        boolean isReadOnly();
        void makeHierarchyReadOnly();
}

Thank you for your patience with me,
Anton




---------------------------------------------------------------------
To unsubscribe, e-mail: [EMAIL PROTECTED]
For additional commands, e-mail: [EMAIL PROTECTED]

Reply via email to