diff options
Diffstat (limited to 'jpa/plugins/org.eclipse.jpt.db/src/org/eclipse/jpt/db/internal/DTPTableWrapper.java')
-rw-r--r-- | jpa/plugins/org.eclipse.jpt.db/src/org/eclipse/jpt/db/internal/DTPTableWrapper.java | 357 |
1 files changed, 0 insertions, 357 deletions
diff --git a/jpa/plugins/org.eclipse.jpt.db/src/org/eclipse/jpt/db/internal/DTPTableWrapper.java b/jpa/plugins/org.eclipse.jpt.db/src/org/eclipse/jpt/db/internal/DTPTableWrapper.java deleted file mode 100644 index 6b271b8c9c..0000000000 --- a/jpa/plugins/org.eclipse.jpt.db/src/org/eclipse/jpt/db/internal/DTPTableWrapper.java +++ /dev/null @@ -1,357 +0,0 @@ -/******************************************************************************* - * Copyright (c) 2006, 2008 Oracle. All rights reserved. - * This program and the accompanying materials are made available under the - * terms of the Eclipse Public License v1.0, which accompanies this distribution - * and is available at http://www.eclipse.org/legal/epl-v10.html. - * - * Contributors: - * Oracle - initial API and implementation - ******************************************************************************/ -package org.eclipse.jpt.db.internal; - -import java.text.Collator; -import java.util.Iterator; -import java.util.List; - -import org.eclipse.datatools.connectivity.sqm.core.rte.ICatalogObject; -import org.eclipse.datatools.modelbase.sql.constraints.PrimaryKey; -import org.eclipse.datatools.modelbase.sql.tables.BaseTable; -import org.eclipse.jpt.db.Column; -import org.eclipse.jpt.db.ForeignKey; -import org.eclipse.jpt.db.Table; -import org.eclipse.jpt.utility.internal.CollectionTools; -import org.eclipse.jpt.utility.internal.NameTools; -import org.eclipse.jpt.utility.internal.StringTools; -import org.eclipse.jpt.utility.internal.iterators.ArrayIterator; -import org.eclipse.jpt.utility.internal.iterators.TransformationIterator; - -/** - * Wrap a DTP Table - */ -final class DTPTableWrapper - extends DTPWrapper - implements Table -{ - // backpointer to parent - private final DTPSchemaWrapper schema; - - // the wrapped DTP table - private final org.eclipse.datatools.modelbase.sql.tables.Table dtpTable; - - // lazy-initialized - private DTPColumnWrapper[] columns; - - // lazy-initialized - private DTPColumnWrapper[] primaryKeyColumns; - - // lazy-initialized - private DTPForeignKeyWrapper[] foreignKeys; - - - private static final DTPColumnWrapper[] EMPTY_COLUMNS = new DTPColumnWrapper[0]; - private static final DTPForeignKeyWrapper[] EMPTY_FOREIGN_KEYS = new DTPForeignKeyWrapper[0]; - - - // ********** constructor ********** - - DTPTableWrapper(DTPSchemaWrapper schema, org.eclipse.datatools.modelbase.sql.tables.Table dtpTable) { - super(schema); - this.schema = schema; - this.dtpTable = dtpTable; - } - - - // ********** DTPWrapper implementation ********** - - @Override - ICatalogObject getCatalogObject() { - return (ICatalogObject) this.dtpTable; - } - - @Override - synchronized void catalogObjectChanged(int eventType) { - // clear stuff so it can be rebuilt - this.dispose_(); - this.getConnectionProfile().tableChanged(this, eventType); - } - - - // ********** Table implementation ********** - - @Override - public String getName() { - return this.dtpTable.getName(); - } - - public String getShortJavaClassName() { - String jName = this.getName(); - if ( ! this.isCaseSensitive()) { - jName = StringTools.capitalize(jName.toLowerCase()); - } - return NameTools.convertToJavaIdentifier(jName); - } - - public boolean matchesShortJavaClassName(String shortJavaClassName) { - return this.isCaseSensitive() ? - this.getName().equals(shortJavaClassName) - : - this.getName().equalsIgnoreCase(shortJavaClassName); - } - - public String getJavaFieldName() { - String jName = this.getName(); - if ( ! this.isCaseSensitive()) { - jName = jName.toLowerCase(); - } - return NameTools.convertToJavaIdentifier(jName); - } - - // ***** columns - - public Iterator<Column> columns() { - return new ArrayIterator<Column>(this.columns_()); - } - - private Iterator<DTPColumnWrapper> columnWrappers() { - return new ArrayIterator<DTPColumnWrapper>(this.columns_()); - } - - private synchronized DTPColumnWrapper[] columns_() { - if (this.columns == null) { - this.columns = this.buildColumns(); - } - return this.columns; - } - - private DTPColumnWrapper[] buildColumns() { - List<org.eclipse.datatools.modelbase.sql.tables.Column> dtpColumns = this.dtpColumns(); - DTPColumnWrapper[] result = new DTPColumnWrapper[dtpColumns.size()]; - for (int i = result.length; i-- > 0;) { - result[i] = new DTPColumnWrapper(this, dtpColumns.get(i)); - } - return result; - } - - // minimize scope of suppressed warnings - @SuppressWarnings("unchecked") - private List<org.eclipse.datatools.modelbase.sql.tables.Column> dtpColumns() { - return this.dtpTable.getColumns(); - } - - public int columnsSize() { - return this.columns_().length; - } - - public Iterator<String> columnNames() { - return new TransformationIterator<DTPColumnWrapper, String>(this.columnWrappers()) { - @Override - protected String transform(DTPColumnWrapper next) { - return next.getName(); - } - }; - } - - public boolean containsColumnNamed(String name) { - return this.columnNamed(name) != null; - } - - public DTPColumnWrapper columnNamed(String name) { - return this.isCaseSensitive() ? this.columnNamedCaseSensitive(name) : this.columnNamedIgnoreCase(name); - } - - private DTPColumnWrapper columnNamedCaseSensitive(String name) { - for (Iterator<DTPColumnWrapper> stream = this.columnWrappers(); stream.hasNext(); ) { - DTPColumnWrapper column = stream.next(); - if (column.getName().equals(name)) { - return column; - } - } - return null; - } - - private DTPColumnWrapper columnNamedIgnoreCase(String name) { - for (Iterator<DTPColumnWrapper> stream = this.columnWrappers(); stream.hasNext(); ) { - DTPColumnWrapper column = stream.next(); - if (StringTools.stringsAreEqualIgnoreCase(column.getName(), name)) { - return column; - } - } - return null; - } - - /** - * return the column for the specified DTP column - */ - DTPColumnWrapper column(org.eclipse.datatools.modelbase.sql.tables.Column dtpColumn) { - if (dtpColumn.getTable() != this.dtpTable) { - return this.schema.column(dtpColumn); - } - for (DTPColumnWrapper column : this.columns_()) { - if (column.wraps(dtpColumn)) { - return column; - } - } - throw new IllegalArgumentException("invalid DTP column: " + dtpColumn); //$NON-NLS-1$ - } - - // ***** primaryKeyColumns - - public Iterator<Column> primaryKeyColumns() { - return new ArrayIterator<Column>(this.primaryKeyColumns_()); - } - - public DTPColumnWrapper primaryKeyColumn() { - DTPColumnWrapper[] pkColumns = this.primaryKeyColumns_(); - if (pkColumns.length != 1) { - throw new IllegalStateException("multiple primary key columns: " + pkColumns.length); //$NON-NLS-1$ - } - return pkColumns[0]; - } - - private synchronized DTPColumnWrapper[] primaryKeyColumns_() { - if (this.primaryKeyColumns == null) { - this.primaryKeyColumns = this.buildPrimaryKeyColumns(); - } - return this.primaryKeyColumns; - } - - private DTPColumnWrapper[] buildPrimaryKeyColumns() { - if ( ! (this.dtpTable instanceof BaseTable)) { - return EMPTY_COLUMNS; - } - PrimaryKey pk = ((BaseTable) this.dtpTable).getPrimaryKey(); - if (pk == null) { - // no PK was defined - return EMPTY_COLUMNS; - } - List<org.eclipse.datatools.modelbase.sql.tables.Column> pkColumns = this.columns(pk); - DTPColumnWrapper[] result = new DTPColumnWrapper[pkColumns.size()]; - for (int i = result.length; i-- > 0;) { - result[i] = this.column(pkColumns.get(i)); - } - return result; - } - - // minimize scope of suppressed warnings - @SuppressWarnings("unchecked") - private List<org.eclipse.datatools.modelbase.sql.tables.Column> columns(PrimaryKey pk) { - return pk.getMembers(); - } - - public int primaryKeyColumnsSize() { - return this.primaryKeyColumns_().length; - } - - public boolean primaryKeyColumnsContains(Column column) { - return CollectionTools.contains(this.primaryKeyColumns_(), column); - } - - // ***** foreignKeys - - public Iterator<ForeignKey> foreignKeys() { - return new ArrayIterator<ForeignKey>(this.foreignKeys_()); - } - - private Iterator<DTPForeignKeyWrapper> foreignKeyWrappers() { - return new ArrayIterator<DTPForeignKeyWrapper>(this.foreignKeys_()); - } - - private synchronized DTPForeignKeyWrapper[] foreignKeys_() { - if (this.foreignKeys == null) { - this.foreignKeys = this.buildForeignKeys(); - } - return this.foreignKeys; - } - - private DTPForeignKeyWrapper[] buildForeignKeys() { - if ( ! (this.dtpTable instanceof BaseTable)) { - return EMPTY_FOREIGN_KEYS; - } - List<org.eclipse.datatools.modelbase.sql.constraints.ForeignKey> dtpForeignKeys = this.dtpForeignKeys(); - DTPForeignKeyWrapper[] result = new DTPForeignKeyWrapper[dtpForeignKeys.size()]; - for (int i = result.length; i-- > 0;) { - result[i] = new DTPForeignKeyWrapper(this, dtpForeignKeys.get(i)); - } - return result; - } - - @SuppressWarnings("unchecked") - private List<org.eclipse.datatools.modelbase.sql.constraints.ForeignKey> dtpForeignKeys() { - return ((BaseTable) this.dtpTable).getForeignKeys(); - } - - public int foreignKeysSize() { - return this.foreignKeys_().length; - } - - public boolean foreignKeyBaseColumnsContains(Column column) { - for (Iterator<DTPForeignKeyWrapper> stream = this.foreignKeyWrappers(); stream.hasNext(); ) { - DTPForeignKeyWrapper foreignKey = stream.next(); - if (foreignKey.baseColumnsContains(column)) { - return true; - } - } - return false; - } - - - // ********** Comparable implementation ********** - - public int compareTo(Table table) { - return Collator.getInstance().compare(this.getName(), table.getName()); - } - - - // ********** internal methods ********** - - boolean wraps(org.eclipse.datatools.modelbase.sql.tables.Table table) { - return this.dtpTable == table; - } - - boolean isCaseSensitive() { - return this.schema.isCaseSensitive(); - } - - DTPTableWrapper table(org.eclipse.datatools.modelbase.sql.tables.Table table) { - return this.schema.table(table); - } - - DTPDatabaseWrapper database() { - return this.schema.database(); - } - - - // ********** disposal ********** - - @Override - synchronized void dispose() { - this.dispose_(); - super.dispose(); - } - - private void dispose_() { - this.disposeForeignKeys(); - // the table does not "contain" the pk columns, so no need to forward #dispose() - this.primaryKeyColumns = null; - this.disposeColumns(); - } - - private void disposeForeignKeys() { - if (this.foreignKeys != null) { - for (DTPForeignKeyWrapper foreignKey : this.foreignKeys) { - foreignKey.dispose(); - } - this.foreignKeys = null; - } - } - - private void disposeColumns() { - if (this.columns != null) { - for (DTPColumnWrapper column : this.columns) { - column.dispose(); - } - this.columns = null; - } - } - -} |