utils/eclipselink.utils.workbench/platformsmodel/source/org/eclipse/persistence/tools/workbench/platformsmodel/DatabaseType.java - eclipselink - Git at Google

 /*******************************************************************************
  * Copyright (c) 1998, 2013 Oracle and/or its affiliates. All rights reserved.
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v1.0 and Eclipse Distribution License v. 1.0
  * which accompanies this distribution.
  * The Eclipse Public License is available at http://www.eclipse.org/legal/epl-v10.html
  * and the Eclipse Distribution License is available at
  * http://www.eclipse.org/org/documents/edl-v10.php.
  *
  * Contributors:
  *     Oracle - initial API and implementation from Oracle TopLink
 ******************************************************************************/
 package org.eclipse.persistence.tools.workbench.platformsmodel;

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

 import org.eclipse.persistence.tools.workbench.utility.ClassTools;
 import org.eclipse.persistence.tools.workbench.utility.XMLTools;
 import org.eclipse.persistence.tools.workbench.utility.node.AbstractNodeModel;
 import org.w3c.dom.Node;


 /**
  * A database type holds all the settings for a platform-specific database type.
  * For example, the Oracle database type VARCHAR2
  * 	- maps to the JDBC type VARCHAR
  * 	- allows and requires a size specification
  * 	- has a initial size of 20 when generating tables
  * 	- does not allow a sub-size specification
  * 	- allows a null value
  */
 public final class DatabaseType
 	extends AbstractNodeModel
 {

 	/**
 	 * a name uniquely identifying the type within a
 	 * database platform
 	 */
 	private String name;
 		public static final String NAME_PROPERTY = "name";

 	/**
 	 * the JDBC type most closely resembling the
 	 * platform-specific database type
 	 */
 	private JDBCType jdbcType;
 		public static final String JDBC_TYPE_PROPERTY = "jdbcType";

 	/**
 	 * whether the type can be declared with a size
 	 */
 	private boolean allowsSize;
 		public static final String ALLOWS_SIZE_PROPERTY = "allowsSize";

 	/**
 	 * whether the type *requires* a size...
 	 */
 	private boolean requiresSize;
 		public static final String REQUIRES_SIZE_PROPERTY = "requiresSize";

 	/**
 	 * ...and, if it does, what the initial size should be
 	 */
 	private int initialSize;
 		public static final String INITIAL_SIZE_PROPERTY = "initialSize";

 	/**
 	 * whether the type can be declared with a "sub-size";
 	 * this is typically a numeric scale
 	 */
 	private boolean allowsSubSize;
 		public static final String ALLOWS_SUB_SIZE_PROPERTY = "allowsSubSize";

 	/**
 	 * whether the type allows NULL values
 	 */
 	private boolean allowsNull;
 		public static final String ALLOWS_NULL_PROPERTY = "allowsNull";


 	// ********** constructors **********

 	/**
 	 * this constructor is called when the type is read from an XML file
 	 */
 	DatabaseType(DatabasePlatform platform, Node node) throws CorruptXMLException {
 		super(platform);
 		this.read(node);
 	}

 	/**
 	 * this constructor is called when the user (or a test case)
 	 * creates a new type (which shouldn't happen very often,
 	 * since all the typical platforms have already been built...)
 	 */
 	DatabaseType(DatabasePlatform platform, String name) {
 		super(platform);
 		this.name = name;
 		this.jdbcType = this.jdbcTypeRepository().getDefaultJDBCType();
 	}


 	// ********** initialization **********

 	/**
 	 * @see org.eclipse.persistence.tools.workbench.utility.AbstractNodeModel#initialize()
 	 */
 	protected void initialize() {
 		super.initialize();
 		this.allowsSize = true;
 		this.requiresSize = false;
 		this.initialSize = 0;
 		this.allowsSubSize = false;
 		this.allowsNull = true;
 	}


 	// ********** accessors **********

 	public DatabasePlatform getPlatform() {
 		return  (DatabasePlatform) this.getParent();
 	}


 	public String getName() {
 		return this.name;
 	}

 	public void setName(String name) {
 		this.getPlatform().checkDatabaseTypeName(name);
 		Object old = this.name;
 		this.name = name;
 		this.firePropertyChanged(NAME_PROPERTY, old, name);
 	}


 	public JDBCType getJDBCType() {
 		return this.jdbcType;
 	}

 	public void setJDBCType(JDBCType jdbcType) {
 		if (jdbcType == null) {
 			throw new NullPointerException();
 		}
 		Object old = this.jdbcType;
 		this.jdbcType = jdbcType;
 		this.firePropertyChanged(JDBC_TYPE_PROPERTY, old, jdbcType);
 	}


 	public boolean allowsSize() {
 		return this.allowsSize;
 	}

 	public void setAllowsSize(boolean allowsSize) {
 		boolean old = this.allowsSize;
 		this.allowsSize = allowsSize;
 		this.firePropertyChanged(ALLOWS_SIZE_PROPERTY, old, allowsSize);

 		// if size is not allowed, sub-size is not either and size cannot be required
 		if ( ! allowsSize) {
 			this.setAllowsSubSize(false);
 			this.setRequiresSize(false);
 		}
 	}


 	public boolean requiresSize() {
 		return this.requiresSize;
 	}

 	public void setRequiresSize(boolean requiresSize) {
 		boolean old = this.requiresSize;
 		this.requiresSize = requiresSize;
 		this.firePropertyChanged(REQUIRES_SIZE_PROPERTY, old, requiresSize);

 		// if size is required, size must be allowed...
 		if (requiresSize) {
 			this.setAllowsSize(true);
 		} else {
 			this.setInitialSize(0);
 		}
 	}


 	public int getInitialSize() {
 		return this.initialSize;
 	}

 	public void setInitialSize(int initialSize) {
 		if (initialSize < 0) {
 			throw new IllegalArgumentException("initial size must be greater than or equal to zero" + initialSize);
 		}
 		int old = this.initialSize;
 		this.initialSize = initialSize;
 		this.firePropertyChanged(INITIAL_SIZE_PROPERTY, old, initialSize);

 		// if there is a initial size, it must be required
 		if (initialSize != 0) {
 			this.setRequiresSize(true);
 		}
 	}


 	public boolean allowsSubSize() {
 		return this.allowsSubSize;
 	}

 	public void setAllowsSubSize(boolean allowsSubSize) {
 		boolean old = this.allowsSubSize;
 		this.allowsSubSize = allowsSubSize;
 		this.firePropertyChanged(ALLOWS_SUB_SIZE_PROPERTY, old, allowsSubSize);

 		// if sub-size is allowed, size must be also
 		if (allowsSubSize) {
 			this.setAllowsSize(true);
 		}
 	}


 	public boolean allowsNull() {
 		return this.allowsNull;
 	}

 	public void setAllowsNull(boolean allowsNull) {
 		boolean old = this.allowsNull;
 		this.allowsNull = allowsNull;
 		this.firePropertyChanged(ALLOWS_NULL_PROPERTY, old, allowsNull);
 	}


 	// ********** queries **********

 	/**
 	 * return a Java type declaration that can used for this database type;
 	 * this is used for generating classes from tables
 	 */
 	public JavaTypeDeclaration javaTypeDeclaration() {
 		return this.jdbcTypeRepository().javaTypeDeclarationFor(this.getJDBCType());
 	}

 	private DatabasePlatformRepository platformRepository() {
 		return this.getPlatform().getRepository();
 	}

 	private JDBCTypeRepository jdbcTypeRepository() {
 		return this.platformRepository().getJDBCTypeRepository();
 	}

 	private JDBCType jdbcTypeNamed(String jdbcTypeName) {
 		return this.jdbcTypeRepository().jdbcTypeNamed(jdbcTypeName);
 	}

 	/**
 	 * Return all the JDBC types that the database type
 	 * could be mapped to. Simplifies UI code....
 	 */
 	public Iterator jdbcTypes() {
 		return this.jdbcTypeRepository().jdbcTypes();
 	}

 	/**
 	 * Return the size of all the JDBC types that the database type
 	 * could be mapped to. Simplifies UI code....
 	 */
 	public int jdbcTypesSize() {
 		return this.jdbcTypeRepository().jdbcTypesSize();
 	}


 	// ********** behavior **********

 	protected void addProblemsTo(List currentProblems) {
 		if (this.requiresSize() && (this.getInitialSize() == 0)) {
 			currentProblems.add(this.buildProblem("003", this.getPlatform().getName(), this.getName()));
 		}
 		super.addProblemsTo(currentProblems);
 	}

 	/**
 	 * @see org.eclipse.persistence.tools.workbench.utility.AbstractNodeModel#nodeRemoved(org.eclipse.persistence.tools.workbench.utility.Node)
 	 */
 	public void nodeRemoved(org.eclipse.persistence.tools.workbench.utility.node.Node node) {
 		super.nodeRemoved(node);
 		if (this.jdbcType == node) {
 			this.setJDBCType(this.jdbcTypeRepository().getDefaultJDBCType());
 		}
 	}

 	/**
 	 * copy all the settings from the original type
 	 * to this, newly-created, type
 	 */
 	void cloneFrom(DatabaseType originalType) {
 		// the name has been set by the time we get here
 		this.setComment(originalType.getComment());
 		this.setJDBCType(originalType.getJDBCType());	// the JDBC type should NOT be cloned
 		this.setAllowsSize(originalType.allowsSize());
 		this.setRequiresSize(originalType.requiresSize());
 		this.setInitialSize(originalType.getInitialSize());
 		this.setAllowsSubSize(originalType.allowsSubSize());
 		this.setAllowsNull(originalType.allowsNull());
 	}


 	// ********** i/o **********

 	private void read(Node node) throws CorruptXMLException {
 		if (node == null) {
 			throw this.buildCorruptXMLException("missing node");
 		}
 		this.name = XMLTools.childTextContent(node, "name", null);
 		if ((this.name == null) || (this.name.length() == 0)) {
 			throw this.buildCorruptXMLException("name is required");
 		}

 		ClassTools.setFieldValue(this, "comment", XMLTools.childTextContent(node, "comment", ""));

 		String jdbcTypeName = XMLTools.childTextContent(node, "jdbc-type", null);
 		try {
 			this.jdbcType = this.jdbcTypeNamed(jdbcTypeName);
 		} catch (IllegalArgumentException ex) {
 			throw this.buildCorruptXMLException(ex);
 		}

 		this.allowsSize = XMLTools.childBooleanContent(node, "allows-size", false);

 		this.requiresSize = XMLTools.childBooleanContent(node, "requires-size", false);
 		if (( ! this.allowsSize) && this.requiresSize) {
 			throw this.buildCorruptXMLException("size cannot be required when it is not allowed");
 		}

 		this.initialSize = XMLTools.childIntContent(node, "initial-size", 0);
 		if (( ! this.requiresSize) && (this.initialSize != 0)) {
 			throw this.buildCorruptXMLException("initial size cannot be specified when size is not required");
 		}

 		this.allowsSubSize = XMLTools.childBooleanContent(node, "allows-sub-size", false);
 		if (( ! this.allowsSize) && this.allowsSubSize) {
 			throw this.buildCorruptXMLException("sub-size cannot be allowed when size is not allowed");
 		}

 		this.allowsNull = XMLTools.childBooleanContent(node, "allows-null", false);
 	}

 	/**
 	 * tack on some more information on the message
 	 */
 	private CorruptXMLException buildCorruptXMLException(String message) {
 		return new CorruptXMLException(message + " (" + this.corruptXMLLocation() + ")");
 	}

 	/**
 	 * tack on some more information on the message
 	 */
 	private CorruptXMLException buildCorruptXMLException(Throwable t) {
 		return new CorruptXMLException(this.corruptXMLLocation(), t);
 	}

 	private String corruptXMLLocation() {
 		return this.getPlatform().getName() + ":" + this.name;
 	}

 	void write(Node node) {
 		XMLTools.addSimpleTextNode(node, "name", this.name);
 		XMLTools.addSimpleTextNode(node, "comment", (String) ClassTools.getFieldValue(this, "comment"), "");
 		XMLTools.addSimpleTextNode(node, "jdbc-type", this.jdbcType.getName());
 		XMLTools.addSimpleTextNode(node, "allows-size", this.allowsSize, false);
 		XMLTools.addSimpleTextNode(node, "requires-size", this.requiresSize, false);
 		XMLTools.addSimpleTextNode(node, "initial-size", this.initialSize, 0);
 		XMLTools.addSimpleTextNode(node, "allows-sub-size", this.allowsSubSize, false);
 		XMLTools.addSimpleTextNode(node, "allows-null", this.allowsNull, false);
 	}


 	// ********** printing and displaying **********

 	/**
 	 * @see org.eclipse.persistence.tools.workbench.utility.Node#displayString()
 	 */
 	public String displayString() {
 		return this.name;
 	}

 	/**
 	 * @see org.eclipse.persistence.tools.workbench.utility.AbstractModel#toString(StringBuffer)
 	 */
 	public void toString(StringBuffer sb) {
 		sb.append(this.name);
 	}

 }
	/*******************************************************************************
	* Copyright (c) 1998, 2013 Oracle and/or its affiliates. All rights reserved.
	* This program and the accompanying materials are made available under the
	* terms of the Eclipse Public License v1.0 and Eclipse Distribution License v. 1.0
	* which accompanies this distribution.
	* The Eclipse Public License is available at http://www.eclipse.org/legal/epl-v10.html
	* and the Eclipse Distribution License is available at
	* http://www.eclipse.org/org/documents/edl-v10.php.
	*
	* Contributors:
	* Oracle - initial API and implementation from Oracle TopLink
	******************************************************************************/
	package org.eclipse.persistence.tools.workbench.platformsmodel;

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

	import org.eclipse.persistence.tools.workbench.utility.ClassTools;
	import org.eclipse.persistence.tools.workbench.utility.XMLTools;
	import org.eclipse.persistence.tools.workbench.utility.node.AbstractNodeModel;
	import org.w3c.dom.Node;


	/**
	* A database type holds all the settings for a platform-specific database type.
	* For example, the Oracle database type VARCHAR2
	* - maps to the JDBC type VARCHAR
	* - allows and requires a size specification
	* - has a initial size of 20 when generating tables
	* - does not allow a sub-size specification
	* - allows a null value
	*/
	public final class DatabaseType
	extends AbstractNodeModel
	{

	/**
	* a name uniquely identifying the type within a
	* database platform
	*/
	private String name;
	public static final String NAME_PROPERTY = "name";

	/**
	* the JDBC type most closely resembling the
	* platform-specific database type
	*/
	private JDBCType jdbcType;
	public static final String JDBC_TYPE_PROPERTY = "jdbcType";

	/**
	* whether the type can be declared with a size
	*/
	private boolean allowsSize;
	public static final String ALLOWS_SIZE_PROPERTY = "allowsSize";

	/**
	* whether the type requires a size...
	*/
	private boolean requiresSize;
	public static final String REQUIRES_SIZE_PROPERTY = "requiresSize";

	/**
	* ...and, if it does, what the initial size should be
	*/
	private int initialSize;
	public static final String INITIAL_SIZE_PROPERTY = "initialSize";

	/**
	* whether the type can be declared with a "sub-size";
	* this is typically a numeric scale
	*/
	private boolean allowsSubSize;
	public static final String ALLOWS_SUB_SIZE_PROPERTY = "allowsSubSize";

	/**
	* whether the type allows NULL values
	*/
	private boolean allowsNull;
	public static final String ALLOWS_NULL_PROPERTY = "allowsNull";


	// ******** constructors ********

	/**
	* this constructor is called when the type is read from an XML file
	*/
	DatabaseType(DatabasePlatform platform, Node node) throws CorruptXMLException {
	super(platform);
	this.read(node);
	}

	/**
	* this constructor is called when the user (or a test case)
	* creates a new type (which shouldn't happen very often,
	* since all the typical platforms have already been built...)
	*/
	DatabaseType(DatabasePlatform platform, String name) {
	super(platform);
	this.name = name;
	this.jdbcType = this.jdbcTypeRepository().getDefaultJDBCType();
	}


	// ******** initialization ********

	/**
	* @see org.eclipse.persistence.tools.workbench.utility.AbstractNodeModel#initialize()
	*/
	protected void initialize() {
	super.initialize();
	this.allowsSize = true;
	this.requiresSize = false;
	this.initialSize = 0;
	this.allowsSubSize = false;
	this.allowsNull = true;
	}


	// ******** accessors ********

	public DatabasePlatform getPlatform() {
	return (DatabasePlatform) this.getParent();
	}


	public String getName() {
	return this.name;
	}

	public void setName(String name) {
	this.getPlatform().checkDatabaseTypeName(name);
	Object old = this.name;
	this.name = name;
	this.firePropertyChanged(NAME_PROPERTY, old, name);
	}


	public JDBCType getJDBCType() {
	return this.jdbcType;
	}

	public void setJDBCType(JDBCType jdbcType) {
	if (jdbcType == null) {
	throw new NullPointerException();
	}
	Object old = this.jdbcType;
	this.jdbcType = jdbcType;
	this.firePropertyChanged(JDBC_TYPE_PROPERTY, old, jdbcType);
	}


	public boolean allowsSize() {
	return this.allowsSize;
	}

	public void setAllowsSize(boolean allowsSize) {
	boolean old = this.allowsSize;
	this.allowsSize = allowsSize;
	this.firePropertyChanged(ALLOWS_SIZE_PROPERTY, old, allowsSize);

	// if size is not allowed, sub-size is not either and size cannot be required
	if ( ! allowsSize) {
	this.setAllowsSubSize(false);
	this.setRequiresSize(false);
	}
	}


	public boolean requiresSize() {
	return this.requiresSize;
	}

	public void setRequiresSize(boolean requiresSize) {
	boolean old = this.requiresSize;
	this.requiresSize = requiresSize;
	this.firePropertyChanged(REQUIRES_SIZE_PROPERTY, old, requiresSize);

	// if size is required, size must be allowed...
	if (requiresSize) {
	this.setAllowsSize(true);
	} else {
	this.setInitialSize(0);
	}
	}


	public int getInitialSize() {
	return this.initialSize;
	}

	public void setInitialSize(int initialSize) {
	if (initialSize < 0) {
	throw new IllegalArgumentException("initial size must be greater than or equal to zero" + initialSize);
	}
	int old = this.initialSize;
	this.initialSize = initialSize;
	this.firePropertyChanged(INITIAL_SIZE_PROPERTY, old, initialSize);

	// if there is a initial size, it must be required
	if (initialSize != 0) {
	this.setRequiresSize(true);
	}
	}


	public boolean allowsSubSize() {
	return this.allowsSubSize;
	}

	public void setAllowsSubSize(boolean allowsSubSize) {
	boolean old = this.allowsSubSize;
	this.allowsSubSize = allowsSubSize;
	this.firePropertyChanged(ALLOWS_SUB_SIZE_PROPERTY, old, allowsSubSize);

	// if sub-size is allowed, size must be also
	if (allowsSubSize) {
	this.setAllowsSize(true);
	}
	}


	public boolean allowsNull() {
	return this.allowsNull;
	}

	public void setAllowsNull(boolean allowsNull) {
	boolean old = this.allowsNull;
	this.allowsNull = allowsNull;
	this.firePropertyChanged(ALLOWS_NULL_PROPERTY, old, allowsNull);
	}


	// ******** queries ********

	/**
	* return a Java type declaration that can used for this database type;
	* this is used for generating classes from tables
	*/
	public JavaTypeDeclaration javaTypeDeclaration() {
	return this.jdbcTypeRepository().javaTypeDeclarationFor(this.getJDBCType());
	}

	private DatabasePlatformRepository platformRepository() {
	return this.getPlatform().getRepository();
	}

	private JDBCTypeRepository jdbcTypeRepository() {
	return this.platformRepository().getJDBCTypeRepository();
	}

	private JDBCType jdbcTypeNamed(String jdbcTypeName) {
	return this.jdbcTypeRepository().jdbcTypeNamed(jdbcTypeName);
	}

	/**
	* Return all the JDBC types that the database type
	* could be mapped to. Simplifies UI code....
	*/
	public Iterator jdbcTypes() {
	return this.jdbcTypeRepository().jdbcTypes();
	}

	/**
	* Return the size of all the JDBC types that the database type
	* could be mapped to. Simplifies UI code....
	*/
	public int jdbcTypesSize() {
	return this.jdbcTypeRepository().jdbcTypesSize();
	}


	// ******** behavior ********

	protected void addProblemsTo(List currentProblems) {
	if (this.requiresSize() && (this.getInitialSize() == 0)) {
	currentProblems.add(this.buildProblem("003", this.getPlatform().getName(), this.getName()));
	}
	super.addProblemsTo(currentProblems);
	}

	/**
	* @see org.eclipse.persistence.tools.workbench.utility.AbstractNodeModel#nodeRemoved(org.eclipse.persistence.tools.workbench.utility.Node)
	*/
	public void nodeRemoved(org.eclipse.persistence.tools.workbench.utility.node.Node node) {
	super.nodeRemoved(node);
	if (this.jdbcType == node) {
	this.setJDBCType(this.jdbcTypeRepository().getDefaultJDBCType());
	}
	}

	/**
	* copy all the settings from the original type
	* to this, newly-created, type
	*/
	void cloneFrom(DatabaseType originalType) {
	// the name has been set by the time we get here
	this.setComment(originalType.getComment());
	this.setJDBCType(originalType.getJDBCType()); // the JDBC type should NOT be cloned
	this.setAllowsSize(originalType.allowsSize());
	this.setRequiresSize(originalType.requiresSize());
	this.setInitialSize(originalType.getInitialSize());
	this.setAllowsSubSize(originalType.allowsSubSize());
	this.setAllowsNull(originalType.allowsNull());
	}


	// ******** i/o ********

	private void read(Node node) throws CorruptXMLException {
	if (node == null) {
	throw this.buildCorruptXMLException("missing node");
	}
	this.name = XMLTools.childTextContent(node, "name", null);
	if ((this.name == null) \|\| (this.name.length() == 0)) {
	throw this.buildCorruptXMLException("name is required");
	}

	ClassTools.setFieldValue(this, "comment", XMLTools.childTextContent(node, "comment", ""));

	String jdbcTypeName = XMLTools.childTextContent(node, "jdbc-type", null);
	try {
	this.jdbcType = this.jdbcTypeNamed(jdbcTypeName);
	} catch (IllegalArgumentException ex) {
	throw this.buildCorruptXMLException(ex);
	}

	this.allowsSize = XMLTools.childBooleanContent(node, "allows-size", false);

	this.requiresSize = XMLTools.childBooleanContent(node, "requires-size", false);
	if (( ! this.allowsSize) && this.requiresSize) {
	throw this.buildCorruptXMLException("size cannot be required when it is not allowed");
	}

	this.initialSize = XMLTools.childIntContent(node, "initial-size", 0);
	if (( ! this.requiresSize) && (this.initialSize != 0)) {
	throw this.buildCorruptXMLException("initial size cannot be specified when size is not required");
	}

	this.allowsSubSize = XMLTools.childBooleanContent(node, "allows-sub-size", false);
	if (( ! this.allowsSize) && this.allowsSubSize) {
	throw this.buildCorruptXMLException("sub-size cannot be allowed when size is not allowed");
	}

	this.allowsNull = XMLTools.childBooleanContent(node, "allows-null", false);
	}

	/**
	* tack on some more information on the message
	*/
	private CorruptXMLException buildCorruptXMLException(String message) {
	return new CorruptXMLException(message + " (" + this.corruptXMLLocation() + ")");
	}

	/**
	* tack on some more information on the message
	*/
	private CorruptXMLException buildCorruptXMLException(Throwable t) {
	return new CorruptXMLException(this.corruptXMLLocation(), t);
	}

	private String corruptXMLLocation() {
	return this.getPlatform().getName() + ":" + this.name;
	}

	void write(Node node) {
	XMLTools.addSimpleTextNode(node, "name", this.name);
	XMLTools.addSimpleTextNode(node, "comment", (String) ClassTools.getFieldValue(this, "comment"), "");
	XMLTools.addSimpleTextNode(node, "jdbc-type", this.jdbcType.getName());
	XMLTools.addSimpleTextNode(node, "allows-size", this.allowsSize, false);
	XMLTools.addSimpleTextNode(node, "requires-size", this.requiresSize, false);
	XMLTools.addSimpleTextNode(node, "initial-size", this.initialSize, 0);
	XMLTools.addSimpleTextNode(node, "allows-sub-size", this.allowsSubSize, false);
	XMLTools.addSimpleTextNode(node, "allows-null", this.allowsNull, false);
	}


	// ******** printing and displaying ********

	/**
	* @see org.eclipse.persistence.tools.workbench.utility.Node#displayString()
	*/
	public String displayString() {
	return this.name;
	}

	/**
	* @see org.eclipse.persistence.tools.workbench.utility.AbstractModel#toString(StringBuffer)
	*/
	public void toString(StringBuffer sb) {
	sb.append(this.name);
	}

	}