All Downloads are FREE. Search and download functionalities are using the official Maven repository.
Please wait. This can take some minutes ...
Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $
You can buy this project and download/modify it how often you want.
javax.faces.model.ResultSetDataModel Maven / Gradle / Ivy
Go to download
This is the master POM file for Oracle's Implementation of the JSF 2.1 Specification.
/*
* 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();
}
}
}