ruper2/src/java/core/org/krysalis/ruper2/util/select Selectable.java,NONE,1.1 SelectorHandlerChain.java,NONE,1.1 Selector.java,NONE,1.1 CompositeSelector.java,NONE,1.1 AllSelector.java,NONE,1.1 SelectionHelper.java,NONE,1.1

Update of 
/cvsroot/metamorphosis/ruper2/src/java/core/org/krysalis/ruper2/util/select
In directory 
sc8-pr-cvs1:/tmp/cvs-serv30481/src/java/core/org/krysalis/ruper2/util/select

Added Files:
        Selectable.java SelectorHandlerChain.java Selector.java 
        CompositeSelector.java AllSelector.java SelectionHelper.java 
Log Message:
Avoid clash with existing Ruper...

--- NEW FILE: Selectable.java ---
/*
 * Created on Aug 27, 2003
 */
package org.krysalis.ruper2.util.select;

/**
 * @author arb_jack
 */
public interface Selectable {
        Object getSelectionObject();
}

--- NEW FILE: SelectorHandlerChain.java ---
/*
 * Created on Sep 11, 2003
  */
package org.krysalis.ruper2.util.select;

import java.util.ArrayList;
import java.util.List;

import org.krysalis.ruper2.util.chainprocess.HandlerChain;

/**
 * @author anou_mana
 */
public class SelectorHandlerChain extends HandlerChain {

        /**
         * @param name
         */
        public SelectorHandlerChain(String name) {
                super(name);
        }

        public List process(final List list) {
                List processedList = new ArrayList(list);
                List selectorList = this.getHandlers();
                if (!selectorList.isEmpty())
                        processedList = SelectionHelper.select(processedList, 
selectorList);

                return processedList;
        }
}

--- NEW FILE: Selector.java ---
/*
 * Created on Aug 27, 2003
 *
 * To change the template for this generated file go to
 * Window>Preferences>Java>Code Generation>Code and Comments
 */
package org.krysalis.ruper2.util.select;

/**
 * @author arb_jack
 */
public interface Selector {
        boolean select(Object o) throws Exception;
}

--- NEW FILE: CompositeSelector.java ---
package org.krysalis.ruper2.util.select;

import org.krysalis.version.util.debug.Dumpable;
import org.krysalis.version.util.debug.DebugUtils;
import org.krysalis.version.util.SystemUtils;

import java.util.List;
import java.util.LinkedList;
import java.util.Iterator;
import java.io.PrintWriter;

/**
 * Abstract selector that is composed of child selectors.  Doesn't
 * specify how the select method should be resolved, that is left
 * to specific implementations.
 *
 * A composite selector maintains the order in which children are added
 * (in case that is significant for the evaluation) and guarantees that
 * children will only be added once.
 *
 * @author Ben Sommerville
 */
public abstract class CompositeSelector implements Selector, Dumpable {
        // Would be much easier if we could use a LinkedHashSet, but that
        // isn't available until JDK 1.4
        private List m_children = new LinkedList();

        /**
         * Add a selector to this composite if it is not already present.
         * If selector has already been added, the add will fail (and
         * return false).
         * @param selector Selector to add
         * @return true if this composite did not already contain the selector
         * @throws NullPointerException If selector is null
         */
        public boolean addSelector(Selector selector) {
                if (selector == null) {
                        throw new IllegalArgumentException("Can't add null 
selector to composite");
                }
                boolean wasAdded;
                if (m_children.contains(selector)) {
                        wasAdded = false;
                }
                else {
                        wasAdded = m_children.add(selector);
                }
                return wasAdded;
        }

        /**
         * Get the number of children
         * @return Number of children
         */
        public int childCount() {
                return m_children.size();
        }

        /**
         * Get an iterator to access children
         * @return Iterator that iterates over children
         */
        public Iterator childIterator() {
                return m_children.iterator();
        }

        /**
         * Check if this selector has children
         * @return true if it has children
         */
        public boolean hasChildren() {
                return !m_children.isEmpty();
        }

        /**
         * Get the name of this type of selector.  This is used for
         * debug output.
         * By default will return type name based on class name
         *
         * @return Selector type name.
         */
        public String getTypeName() {
                String name = SystemUtils.getShortName(this);
                String selectorSuffix = "Selector";
                if (name.endsWith(selectorSuffix)) {
                        name = name.substring(0, name.length() - 
selectorSuffix.length());
                }
                return name;
        }

        /**
         * Override of equals method (@see java.lang.Object#equals).
         * CompositeSelectors are equal if they are of the same
         * type and have the same children (number and order).
         * @param obj Object compare with
         * @return True if objects are equal
         */
        public boolean equals(Object obj) {
                boolean isEqual = false;

                if (sameType(obj)) {
                        CompositeSelector rhs = (CompositeSelector) obj;
                        if (childCount() == rhs.childCount()) {
                                Iterator lhsIter = childIterator();
                                Iterator rhsIter = rhs.childIterator();
                                isEqual = true;
                                while (lhsIter.hasNext() && rhsIter.hasNext() 
&& isEqual) {
                                        Object lhsChild = lhsIter.next();
                                        Object rhsChild = rhsIter.next();
                                        isEqual = lhsChild.equals(rhsChild);
                                }
                        }
                }
                return isEqual;
        }

        public int hashCode() {
                int typeHash = getType().hashCode();
                return typeHash * 41 + m_children.hashCode();
        }

        public void dump(PrintWriter out, int depth, boolean verbose) {
                String indent = DebugUtils.getIndent(depth);
                out.print(indent);
                out.print(getTypeName());
                out.println(" (");
                Iterator iter = childIterator();
                while (iter.hasNext()) {
                        Selector selector = (Selector) iter.next();
                        DebugUtils.dump(out, depth + 1, verbose, selector);
                }

                out.print(indent);
                out.println(")");

        }
        public String toString() {
                StringBuffer buffer = new StringBuffer();

                buffer.append(getTypeName());

                buffer.append(" (");
                Iterator iter = childIterator();
                while (iter.hasNext()) {
                        Selector selector = (Selector) iter.next();
                        buffer.append(selector);
                }

                buffer.append(")");

                return buffer.toString();
        }

        /**
         * Determine if object is same type of selector
         * @param obj Object to check
         * @return true if the types are the same
         */
        private boolean sameType(Object obj) {
                boolean isSame = false;
                if (obj instanceof CompositeSelector) {
                        CompositeSelector rhs = (CompositeSelector) obj;
                        return getType().equals(rhs.getType());
                }
                return isSame;
        }

        /**
         * Get an object representing the selector type
         * @return Type object
         */
        private Object getType() {
                return getClass();
        }
}

--- NEW FILE: AllSelector.java ---
/*
 * Created on Aug 27, 2003
 */
package org.krysalis.ruper2.util.select;

import org.krysalis.version.util.SystemUtils;

/**
 * @author arb_jack
 */
public class AllSelector implements Selector {

        private final static Selector INSTANCE = new AllSelector();

        /* (non-Javadoc)
         * @see org.krysalis.ruper2.util.Selector#select(java.lang.Object)
         */
        public boolean select(Object o) {
                return true;
        }

        public static Selector getInstance() {
                return AllSelector.INSTANCE;
        }
        
        public String toString() { return SystemUtils.getShortName(getClass()); 
}
}

--- NEW FILE: SelectionHelper.java ---
/*
 * Created on Aug 27, 2003
 */
package org.krysalis.ruper2.util.select;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

import org.krysalis.ruper2.log.Logger;
import org.krysalis.ruper2.util.text.Messages;

/**
 * @author arb_jack
 */
public class SelectionHelper {

        /**
         * Apply a "chain" (list) of selectors to a collection
         * 
         * @param choices
         * @param selectors
         * @return
         */
        public static List select(List choices, List selectors) {
                List selected = new ArrayList();
                selectInto(choices, selectors, selected);
                return selected;
        }

        /**
         * Apply a "chain" (list) of selectors to a collection
         * 
         * @param choices
         * @param selectors
         * @return
         */
        public static void selectInto(
                List choices,
                List selectors,
                List selected) {
                //
                // Keep applying selectors (so long as there are choices)
                //
                for (Iterator i = selectors.iterator();
                        i.hasNext() && !choices.isEmpty();
                        ) {
                        Selector selector = (Selector) i.next();

                        selectInto(choices, selector, selected);

                        choices = selected;
                        selected = new ArrayList();  // clean selection
                }
                
                selected = choices;
        }

        public static List select(List choices, Selector selector) {
                List selected = new ArrayList();
                selectInto(choices, selector, selected);
                return selected;
        }

        public static void selectInto(
                List choices,
                Selector selector,
                List selected) {

                for (Iterator i = choices.iterator(); i.hasNext();) {
                        Object choice = i.next();
                        try {
                                if (selector.select(choice))
                                        selected.add(choice);
                                else
                                        Logger.getLog().debug(
                                                Messages.getString(
                                                        "NOT_SELECTED",
                                                        new Object[] { choice, 
selector }));
                        }
                        catch (Exception e) {
                                Logger.getLog().error(
                                        Messages.getString(
                                                "SELECTOR_CRASHED",
                                                new Object[] { selector, e }),
                                        e);
                        }
                }
        }
}



-------------------------------------------------------
This sf.net email is sponsored by:ThinkGeek
Welcome to geek heaven.
http://thinkgeek.com/sf