path: root/jpa/plugins/org.eclipse.jpt.db/src/org/eclipse/jpt/db/internal/DTPSchemaWrapper.java

/*******************************************************************************
 * 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.jpt.db.Schema;
import org.eclipse.jpt.db.Sequence;
import org.eclipse.jpt.db.Table;
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 Schema
 */
final class DTPSchemaWrapper
	extends DTPWrapper
	implements Schema
{
	// backpointer to parent
	private final DTPSchemaContainerWrapper container;

	// the wrapped DTP schema
	private final org.eclipse.datatools.modelbase.sql.schema.Schema dtpSchema;

	// lazy-initialized
	private DTPTableWrapper[] tables;

	// lazy-initialized
	private DTPSequenceWrapper[] sequences;


	// ********** constructor **********

	DTPSchemaWrapper(DTPSchemaContainerWrapper container, org.eclipse.datatools.modelbase.sql.schema.Schema dtpSchema) {
		super(container, dtpSchema);
		this.container = container;
		this.dtpSchema = dtpSchema;
	}


	// ********** DTPWrapper implementation **********

	@Override
	synchronized void catalogObjectChanged(int eventType) {
		// clear stuff so it can be rebuilt
		this.dispose_();
		this.getConnectionProfile().schemaChanged(this, eventType);
	}


	// ********** Schema implementation **********

	@Override
	public String getName() {
		return this.dtpSchema.getName();
	}

	// ***** tables

	public Iterator<Table> tables() {
		return new ArrayIterator<Table>(this.tables_());
	}

	private Iterator<DTPTableWrapper> tableWrappers() {
		return new ArrayIterator<DTPTableWrapper>(this.tables_());
	}

	private synchronized DTPTableWrapper[] tables_() {
		if (this.tables == null) {
			this.tables = this.buildTables();
		}
		return this.tables;
	}

	private DTPTableWrapper[] buildTables() {
		List<org.eclipse.datatools.modelbase.sql.tables.Table> dtpTables = this.dtpTables();
		DTPTableWrapper[] result = new DTPTableWrapper[dtpTables.size()];
		for (int i = result.length; i-- > 0;) {
			result[i] = new DTPTableWrapper(this, dtpTables.get(i));
		}
		return result;
	}

	// minimize scope of suppressed warnings
	@SuppressWarnings("unchecked")
	private List<org.eclipse.datatools.modelbase.sql.tables.Table> dtpTables() {
		return this.dtpSchema.getTables();
	}

	public int tablesSize() {
		return this.tables_().length;
	}

	public Iterator<String> tableNames() {
		return new TransformationIterator<DTPTableWrapper, String>(this.tableWrappers()) {
			@Override
			protected String transform(DTPTableWrapper table) {
				 return table.getName();
			}
		};
	}

	public boolean containsTableNamed(String name) {
		return this.tableNamed(name) != null;
	}

	public DTPTableWrapper tableNamed(String name) {
		return this.isCaseSensitive() ? this.tableNamedCaseSensitive(name) : this.tableNamedIgnoreCase(name);
	}

	private DTPTableWrapper tableNamedCaseSensitive(String name) {
		for (Iterator<DTPTableWrapper> stream = this.tableWrappers(); stream.hasNext(); ) {
			DTPTableWrapper table = stream.next();
			if (table.getName().equals(name)) {
				return table;
			}
		}
		return null;
	}

	private DTPTableWrapper tableNamedIgnoreCase(String name) {
		for (Iterator<DTPTableWrapper> stream = this.tableWrappers(); stream.hasNext(); ) {
			DTPTableWrapper table = stream.next();
			if (StringTools.stringsAreEqualIgnoreCase(table.getName(), name)) {
				return table;
			}
		}
		return null;
	}

	/**
	 * return the table for the specified DTP table
	 */
	DTPTableWrapper table(org.eclipse.datatools.modelbase.sql.tables.Table dtpTable) {
		if (dtpTable.getSchema() != this.dtpSchema) {
			return this.database().table(dtpTable);
		}
		for (Iterator<DTPTableWrapper> stream = this.tableWrappers(); stream.hasNext(); ) {
			DTPTableWrapper table = stream.next();
			if (table.wraps(dtpTable)) {
				return table;
			}
		}
		throw new IllegalArgumentException("invalid DTP table: " + dtpTable);  //$NON-NLS-1$
	}

	// ***** sequences

	public Iterator<Sequence> sequences() {
		return new ArrayIterator<Sequence>(this.sequences_());
	}

	private Iterator<DTPSequenceWrapper> sequenceWrappers() {
		return new ArrayIterator<DTPSequenceWrapper>(this.sequences_());
	}

	private synchronized DTPSequenceWrapper[] sequences_() {
		if (this.sequences == null) {
			this.sequences = this.buildSequences();
		}
		return this.sequences;
	}

	private DTPSequenceWrapper[] buildSequences() {
		List<org.eclipse.datatools.modelbase.sql.schema.Sequence> dtpSequences = this.dtpSequences();
		DTPSequenceWrapper[] result = new DTPSequenceWrapper[dtpSequences.size()];
		for (int i = result.length; i-- > 0;) {
			result[i] = new DTPSequenceWrapper(this, dtpSequences.get(i));
		}
		return result;
	}

	// minimize scope of suppressed warnings
	@SuppressWarnings("unchecked")
	private List<org.eclipse.datatools.modelbase.sql.schema.Sequence> dtpSequences() {
		return this.dtpSchema.getSequences();
	}

	public int sequencesSize() {
		return this.sequences_().length;
	}

	public Iterator<String> sequenceNames() {
		return new TransformationIterator<DTPSequenceWrapper, String>(this.sequenceWrappers()) {
			@Override
			protected String transform(DTPSequenceWrapper sequence) {
				 return sequence.getName();
			}
		};
	}

	public boolean containsSequenceNamed(String name) {
		return this.sequenceNamed(name) != null;
	}

	public DTPSequenceWrapper sequenceNamed(String name) {
		return this.isCaseSensitive() ? this.sequenceNamedCaseSensitive(name) : this.sequenceNamedIgnoreCase(name);
	}
	
	private DTPSequenceWrapper sequenceNamedCaseSensitive(String name) {
		for (Iterator<DTPSequenceWrapper> stream = this.sequenceWrappers(); stream.hasNext(); ) {
			DTPSequenceWrapper sequence = stream.next();
			if (sequence.getName().equals(name)) {
				return sequence;
			}
		}
		return null;
	}

	private DTPSequenceWrapper sequenceNamedIgnoreCase(String name) {
		for (Iterator<DTPSequenceWrapper> stream = this.sequenceWrappers(); stream.hasNext(); ) {
			DTPSequenceWrapper sequence = stream.next();
			if (sequence.getName().equalsIgnoreCase(name)) {
				return sequence;
			}
		}
		return null;
	}


	// ********** Comparable implementation **********

	public int compareTo(Schema schema) {
		return Collator.getInstance().compare(this.getName(), schema.getName());
	}


	// ********** internal methods **********

	boolean wraps(org.eclipse.datatools.modelbase.sql.schema.Schema schema) {
		return this.dtpSchema == schema;
	}

	boolean isCaseSensitive() {
		return this.database().isCaseSensitive();
	}

	DTPColumnWrapper column(org.eclipse.datatools.modelbase.sql.tables.Column dtpColumn) {
		return this.database().column(dtpColumn);
	}

	DTPDatabaseWrapper database() {
		return this.container.database();
	}


	// ********** disposal **********

	@Override
	synchronized void dispose() {
		this.dispose_();
		super.dispose();
	}

	private void dispose_() {
		this.disposeSequences();
		this.disposeTables();
	}

	private void disposeSequences() {
		if (this.sequences != null) {
			for (DTPSequenceWrapper sequence : this.sequences) {
				sequence.dispose();
			}
			this.sequences = null;
		}
	}

	private void disposeTables() {
		if (this.tables != null) {
			for (DTPTableWrapper table : this.tables) {
				table.dispose();
			}
			this.tables = null;
		}
	}

}