All Downloads are FREE. Search and download functionalities are using the official Maven repository.

javax.faces.model.ResultSetDataModel Maven / Gradle / Ivy

Go to download

This is the master POM file for Sun's Implementation of the JSF 2.1 Specification.

There is a newer version: 2.2.20
Show newest version
/*
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
 *
 * Copyright (c) 1997-2010 Oracle and/or its affiliates. All rights reserved.
 *
 * The contents of this file are subject to the terms of either the GNU
 * General Public License Version 2 only ("GPL") or the Common Development
 * and Distribution License("CDDL") (collectively, the "License").  You
 * may not use this file except in compliance with the License.  You can
 * obtain a copy of the License at
 * https://glassfish.dev.java.net/public/CDDL+GPL_1_1.html
 * or packager/legal/LICENSE.txt.  See the License for the specific
 * language governing permissions and limitations under the License.
 *
 * When distributing the software, include this License Header Notice in each
 * file and include the License file at packager/legal/LICENSE.txt.
 *
 * GPL Classpath Exception:
 * Oracle designates this particular file as subject to the "Classpath"
 * exception as provided by Oracle in the GPL Version 2 section of the License
 * file that accompanied this code.
 *
 * Modifications:
 * If applicable, add the following below the License Header, with the fields
 * enclosed by brackets [] replaced by your own identifying information:
 * "Portions Copyright [year] [name of copyright owner]"
 *
 * Contributor(s):
 * If you wish your version of this file to be governed by only the CDDL or
 * only the GPL Version 2, indicate your decision by adding "[Contributor]
 * elects to include this software in this distribution under the [CDDL or GPL
 * Version 2] license."  If you don't indicate a single choice of license, a
 * recipient has the option to distribute your version of this file under
 * either the CDDL, the GPL Version 2 or to extend the choice of license to
 * its licensees as provided above.  However, if you add GPL Version 2 code
 * and therefore, elected the GPL Version 2 license, then the option applies
 * only if the new code is made subject to such option by the copyright
 * holder.
 */

package javax.faces.model;


import java.sql.ResultSet;
import java.sql.ResultSetMetaData;
import java.sql.SQLException;
import java.util.AbstractCollection;
import java.util.AbstractSet;
import java.util.Collection;
import java.util.Comparator;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
import java.util.TreeMap;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.NotSerializableException;
import java.io.ObjectOutputStream;

import javax.faces.FacesException;


/**
 * 
ResultSetDataModel is a convenience implementation of
 * {@link DataModel} that wraps a ResultSet of Java objects.
 * Note that the specified ResultSet MUST
 * be scrollable.  In addition, if input components (that will be updating
 * model values) reference this object in value binding expressions, the
 * specified ResultSet MUST be updatable.

 */

public class ResultSetDataModel extends DataModel> {


    // ------------------------------------------------------------ Constructors


    /**
     * 
Construct a new {@link ResultSetDataModel} with no specified
     * wrapped data.

     */
    public ResultSetDataModel() {

        this(null);

    }


    /**
     * 
Construct a new {@link ResultSetDataModel} wrapping the specified
     * ResultSet.

     *
     * @param resultSet ResultSet to be wrapped (if any)
     */
    public ResultSetDataModel(ResultSet resultSet) {

        super();
        setWrappedData(resultSet);

    }


    // ------------------------------------------------------ Instance Variables


    // The current row index (zero relative)
    private int index = -1;


    // The metadata for the ResultSet we are wrapping (lazily instantiated)
    private ResultSetMetaData metadata = null;


    // The ResultSet we are wrapping
    private ResultSet resultSet = null;


    // Has the row at the current index been updated?
    private boolean updated = false;


    // -------------------------------------------------------------- Properties


    /**
     * 
Return true if there is wrappedData
     * available, and the result of calling absolute() on the
     * underlying ResultSet, passing the current value of
     * rowIndex plus one (to account for the fact that
     * ResultSet uses one-relative indexing), returns
     * true.  Otherwise, return false.

     *
     * @throws FacesException if an error occurs getting the row availability
     */ 
    public boolean isRowAvailable() {

        if (resultSet == null) {
	    return (false);
        } else if (index < 0) {
            return (false);
        }
        try {
            if (resultSet.absolute(index + 1)) {
                return (true);
            } else {
                return (false);
            }
        } catch (SQLException e) {
            throw new FacesException(e);
        }

    }


    /**
     * 
Return -1, since ResultSet does not provide a
     * standard way to determine the number of available rows without
     * scrolling through the entire ResultSet, and this can
     * be very expensive if the number of rows is large.

     *
     * @throws FacesException if an error occurs getting the row count
     */
    public int getRowCount() {

	return (-1);

    }


    /**
     * 
If row data is available, return a Map representing
     * the values of the columns for the row specified by rowIndex,
     * keyed by the corresponding column names.  If no wrapped data is
     * available, return null.

     *
     * 
If a non-null Map is returned, its behavior
     * must correspond to the contract for a mutable Map as
     * described in the JavaDocs for AbstractMap, with the
     * following exceptions and specialized behavior:

     * 
    

     * 
  • The Map, and any supporting objects it returns,
     *     must perform all column name comparisons in a
     *     case-insensitive manner.  This case-insensitivity must be
     *     implemented using a case-insensitive Comparator,
     *     such as
     *     String.CASE_INSENSITIVE_ORDER.
    • 

     * 
  • The following methods must throw
     *     UnsupportedOperationException:  clear(),
     *     remove().
    • 
     * 
  • The entrySet() method must return a Set
     *     that has the following behavior:
     *     
      
     *     
    • Throw UnsupportedOperationException for any attempt
     *         to add or remove entries from the Set, either
     *         directly or indirectly through an Iterator
     *         returned by the Set.
      • 
     *     
    • Updates to the value of an entry in this
     *         set must write through to the corresponding
     *         column value in the underlying ResultSet.
      • 
     *     
    • 
     * 
  • The keySet() method must return a Set
     *     that throws UnsupportedOperationException on any
     *     attempt to add or remove keys, either directly or through an
     *     Iterator returned by the Set.
    • 
     * 
  • The put() method must throw
     *     IllegalArgumentException if a key value for which
     *     containsKey() returns false is
     *     specified.  However, if a key already present in the Map
     *     is specified, the specified value must write through to the
     *     corresponding column value in the underlying ResultSet.
     *     
    • 
     * 
  • The values() method must return a
     *     Collection that throws
     *     UnsupportedOperationException on any attempt to add
     *     or remove values, either directly or through an Iterator
     *     returned by the Collection.
    • 
     * 

     *
     * @throws FacesException if an error occurs getting the row data
     * @throws IllegalArgumentException if now row data is available
     *  at the currently specified row index
     */ 
    public Map getRowData() {

        if (resultSet == null) {
	    return (null);
        } else if (!isRowAvailable()) {
            throw new NoRowAvailableException();
        }
        try {
            getMetaData();
            return (new ResultSetMap(this, String.CASE_INSENSITIVE_ORDER));
        } catch (SQLException e) {
            throw new FacesException(e);
        }

    }


    /**
     * @throws FacesException {@inheritDoc}     
     */ 
    public int getRowIndex() {

        return (index);

    }


    /**
     * @throws FacesException {@inheritDoc}
     * @throws IllegalArgumentException {@inheritDoc}
     */ 
    public void setRowIndex(int rowIndex) {

        if (rowIndex < -1) {
            throw new IllegalArgumentException();
        }

        // Tell the ResultSet that the previous row was updated if necessary
        if (updated && (resultSet != null)) {
            try {
		if (!resultSet.rowDeleted()) {
		    resultSet.updateRow();
		}
                updated = false;
            } catch (SQLException e) {
                throw new FacesException(e);
            }
        }

        int old = index;
        index = rowIndex;
	if (resultSet == null) {
	    return;
	}
	DataModelListener [] listeners = getDataModelListeners();
        if ((old != index) && (listeners != null)) {
            Object rowData = null;
            if (isRowAvailable()) {
                rowData = getRowData();
            }
            DataModelEvent event =
                new DataModelEvent(this, index, rowData);
            int n = listeners.length;
            for (int i = 0; i < n; i++) {
		if (null != listeners[i]) {
		    listeners[i].rowSelected(event);
		}
            }
        }


    }


    public Object getWrappedData() {

        return (this.resultSet);

    }


    /**
     * @throws ClassCastException {@inheritDoc}
     */
    public void setWrappedData(Object data) {

        if (data == null) {
            metadata = null;
            resultSet = null;
            setRowIndex(-1);
        } else {
            metadata = null;
            resultSet = (ResultSet) data;
            index = -1;
            setRowIndex(0);
        }
    }


    // --------------------------------------------------------- Private Methods


    /**
     * 
Return the ResultSetMetaData for the
     * ResultSet we are wrapping, caching it the first time
     * it is returned.

     *
     * @throws FacesException if the ResultSetMetaData
     *  cannot be acquired
     */
    private ResultSetMetaData getMetaData() {

        if (metadata == null) {
            try {
                metadata = resultSet.getMetaData();
            } catch (SQLException e) {
                throw new FacesException(e);
            }
        }
        return (metadata);

    }


    /**
     * 
Mark the current row as having been updated, so that we will call
     * updateRow() before moving elsewhere.

     */
    private void updated() {

        this.updated = true;

    }


    // --------------------------------------------------------- Private Classes


    // Private implementation of Map that delegates column get and put
    // operations to the underlying ResultSet, after setting the required
    // row index
    // NOT SERIALIZABLE
    @SuppressWarnings({"serial"})
    private static class ResultSetMap extends TreeMap {

        private ResultSetDataModel model;

        public ResultSetMap(ResultSetDataModel model,
                            Comparator comparator) throws SQLException {

            super(comparator);
            this.model = model;
            index = model.index;
            model.resultSet.absolute(index + 1);
            int n = model.metadata.getColumnCount();
            for (int i = 1; i <= n; i++) {
                super.put(model.metadata.getColumnName(i),
                          model.metadata.getColumnName(i));
            }
        }

        // The zero-relative row index of our row
        private int index;

        // Removing entries is not allowed
        public void clear() {
            throw new UnsupportedOperationException();
        }

        public boolean containsValue(Object value) {
            for (Iterator i = entrySet().iterator(); i .hasNext(); ) {
                Map.Entry entry = (Map.Entry) i.next();
                Object contained = entry.getValue();
                 if (value == null) {
                    if (contained == null) {
                        return (true);
                    }
                } else {
                    if (value.equals(contained)) {
                        return (true);
                    }
                }
            }
            return (false);
        }

        public Set> entrySet() {
            return (new ResultSetEntries(this));
        }

        public Object get(Object key) {
            if (!containsKey(key)) {
                return (null);
            }
            try {
                model.resultSet.absolute(index + 1);
                return (model.resultSet.getObject((String) realKey(key)));
            } catch (SQLException e) {
                throw new FacesException(e);
            }
        }

        public Set keySet() {
            return (new ResultSetKeys(this));
        }

        public Object put(String key, Object value) {
            if (!containsKey(key)) {
                throw new IllegalArgumentException();
            }
            
            try {
                model.resultSet.absolute(index + 1);
                Object previous = model.resultSet.getObject((String) realKey(key));
                if ((previous == null) && (value == null)) {
                    return (previous);
                } else if ((previous != null) && (value != null) &&
                           previous.equals(value)) {
                    return (previous);
                }
                model.resultSet.updateObject((String) realKey(key), value);
                model.updated();
                return (previous);
            } catch (SQLException e) {
                throw new FacesException(e);
            }
        }

        public void putAll(Map map) {
            for (Map.Entry entry : map.entrySet()) {
                put(entry.getKey(), entry.getValue());
            }
        }

        // Removing entries is not allowed
        public Object remove(Object key) {
            throw new UnsupportedOperationException();
        }

        public Collection values() {
            return (new ResultSetValues(this));
        }

        Object realKey(Object key) {
            return (super.get(key));
        }

        Iterator realKeys() {
            return (super.keySet().iterator());
        }

        private void writeObject(ObjectOutputStream out) throws IOException {
            throw new NotSerializableException();
        }

        private void readObject(ObjectInputStream in) throws IOException {
            throw new NotSerializableException();
        }

    }


    // Private implementation of Set that implements the entrySet() behavior
    // for ResultSetMap
    private static class ResultSetEntries extends AbstractSet> {

        public ResultSetEntries(ResultSetMap map) {
            this.map = map;
        }

        private ResultSetMap map;

        // Adding entries is not allowed
        public boolean add(Map.Entry o) {
            throw new UnsupportedOperationException();
        }

        // Adding entries is not allowed
        public boolean addAll(Collection c) {
            throw new UnsupportedOperationException();
        }

        // Removing entries is not allowed
        public void clear() {
            throw new UnsupportedOperationException();
        }

        public boolean contains(Object o) {
            if (o == null) {
                throw new NullPointerException();
            }
            if (!(o instanceof Map.Entry)) {
                return (false);
            }
            Map.Entry e = (Map.Entry) o;
            Object k = e.getKey();
            Object v = e.getValue();
            if (!map.containsKey(k)) {
                return (false);
            }
            if (v == null) {
                return (map.get(k) == null);
            } else {
                return (v.equals(map.get(k)));
            }
        }

        public boolean isEmpty() {
            return (map.isEmpty());
        }

        public Iterator> iterator() {
            return (new ResultSetEntriesIterator(map));
        }

        // Removing entries is not allowed
        public boolean remove(Object o) {
            throw new UnsupportedOperationException();
        }

        // Removing entries is not allowed
        public boolean removeAll(Collection c) {
            throw new UnsupportedOperationException();
        }

        // Removing entries is not allowed
        public boolean retainAll(Collection c) {
            throw new UnsupportedOperationException();
        }

        public int size() {
            return (map.size());
        }

    }


    // Private implementation of Iterator that implements the iterator()
    // behavior for the Set returned by entrySet() from ResultSetMap
    private static class ResultSetEntriesIterator implements Iterator> {

        public ResultSetEntriesIterator(ResultSetMap map) {
            this.map = map;
            this.keys = map.keySet().iterator();
        }

        private ResultSetMap map = null;
        private Iterator keys = null;

        public boolean hasNext() {
            return (keys.hasNext());
        }

        public Map.Entry next() {
            String key = keys.next();
            return (new ResultSetEntry(map, key));
        }

        // Removing entries is not allowed
        public void remove() {
            throw new UnsupportedOperationException();
        }

    }


    // Private implementation of Map.Entry that implements the behavior for
    // a single entry from the Set returned by entrySet() from ResultSetMap
    private static class ResultSetEntry implements Map.Entry {

        public ResultSetEntry(ResultSetMap map, String key) {
            this.map = map;
            this.key = key;
        }

        private ResultSetMap map;
        private String key;

        public boolean equals(Object o) {
            if (o == null) {
                return (false);
            }
            if (!(o instanceof Map.Entry)) {
                return (false);
            }
            Map.Entry e = (Map.Entry) o;
            if (key == null) {
                if (e.getKey() != null) {
                    return (false);
                }
            } else {
                if (!key.equals(e.getKey())) {
                    return (false);
                }
            }
            Object v = map.get(key);
            if (v == null) {
                if (e.getValue() != null) {
                    return (false);
                }
            } else {
                if (!v.equals(e.getValue())) {
                    return (false);
                }
            }
            return (true);
        }

        public String getKey() {
            return (key);
        }

        public Object getValue() {
            return (map.get(key));
        }

        public int hashCode() {
            Object value = map.get(key);
            return (((key == null) ? 0 : key.hashCode()) ^
                    ((value == null) ? 0 : value.hashCode()));
        }

        public Object setValue(Object value) {
            Object previous = map.get(key);
            map.put(key, value);
            return (previous);
        }

    }


    // Private implementation of Set that implements the keySet() behavior
    // for ResultSetMap
    private static class ResultSetKeys extends AbstractSet {

        public ResultSetKeys(ResultSetMap map) {
            this.map = map;
        }

        private ResultSetMap map;

        // Adding keys is not allowed
        public boolean add(String o) {
            throw new UnsupportedOperationException();
        }

        // Adding keys is not allowed
        public boolean addAll(Collection c) {
            throw new UnsupportedOperationException();
        }

        // Removing keys is not allowed
        public void clear() {
            throw new UnsupportedOperationException();
        }

        public boolean contains(Object o) {
            return (map.containsKey(o));
        }

        public boolean isEmpty() {
            return (map.isEmpty());
        }

        public Iterator iterator() {
            return (new ResultSetKeysIterator(map));
        }

        // Removing keys is not allowed
        public boolean remove(Object o) {
            throw new UnsupportedOperationException();
        }

        // Removing keys is not allowed
        public boolean removeAll(Collection c) {
            throw new UnsupportedOperationException();
        }

        // Removing keys is not allowed
        public boolean retainAll(Collection c) {
            throw new UnsupportedOperationException();
        }

        public int size() {
            return (map.size());
        }

    }


    // Private implementation of Iterator that implements the iterator()
    // behavior for the Set returned by keySet() from ResultSetMap
    private static class ResultSetKeysIterator implements Iterator {

        public ResultSetKeysIterator(ResultSetMap map) {
            this.keys = map.realKeys();
        }

        private Iterator keys = null;

        public boolean hasNext() {
            return (keys.hasNext());
        }

        public String next() {
            return (keys.next());
        }

        // Removing keys is not allowed
        public void remove() {
            throw new UnsupportedOperationException();
        }

    }


    // Private implementation of Collection that implements the behavior
    // for the Collection returned by values() from ResultSetMap
    private static class ResultSetValues extends AbstractCollection {

        public ResultSetValues(ResultSetMap map) {
            this.map = map;
        }

        private ResultSetMap map;

        public boolean add(Object o) {
            throw new UnsupportedOperationException();
        }

        public boolean addAll(Collection c) {
            throw new UnsupportedOperationException();
        }

        public void clear() {
            throw new UnsupportedOperationException();
        }

        public boolean contains(Object value) {
            return (map.containsValue(value));
        }

        public Iterator iterator() {
            return (new ResultSetValuesIterator(map));
        }

        public boolean remove(Object o) {
            throw new UnsupportedOperationException();
        }

        public boolean removeAll(Collection c) {
            throw new UnsupportedOperationException();
        }

        public boolean retainAll(Collection c) {
            throw new UnsupportedOperationException();
        }

        public int size() {
            return (map.size());
        }

    }


    // Private implementation of Iterator that implements the behavior
    // for the Iterator returned by values().iterator() from ResultSetMap
    private static class ResultSetValuesIterator implements Iterator {

        public ResultSetValuesIterator(ResultSetMap map) {
            this.map = map;
            this.keys = map.keySet().iterator();
        }

        private ResultSetMap map;
        private Iterator keys;

        public boolean hasNext() {
            return (keys.hasNext());
        }

        public Object next() {
            return (map.get(keys.next()));
        }

        public void remove() {
            throw new UnsupportedOperationException();
        }

    }


}
    

    

    
            
    
            







    
© 2015 - 2024 Weber Informatics LLC | Privacy Policy