package org.apache.torque.engine.database.model;
/*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied. See the License for the
* specific language governing permissions and limitations
* under the License.
*/
import java.util.ArrayList;
import java.util.Collections;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import org.apache.commons.collections.map.ListOrderedMap;
import org.apache.commons.lang.StringUtils;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.apache.torque.engine.EngineException;
import org.apache.torque.engine.platform.Platform;
import org.apache.torque.engine.platform.PlatformDefaultImpl;
import org.xml.sax.Attributes;
/**
* A Class for holding data about a column used in an Application.
*
* @author <a href="mailto:leon@opticode.co.za">Leon Messerschmidt</a>
* @author <a href="mailto:jvanzyl@apache.org">Jason van Zyl</a>
* @author <a href="mailto:jon@latchkey.com">Jon S. Stevens</a>
* @author <a href="mailto:dlr@finemaltcoding.com">Daniel Rall</a>
* @author <a href="mailto:byron_foster@byron_foster@yahoo.com>Byron Foster</a>
* @author <a href="mailto:mpoeschl@marmot.at>Martin Poeschl</a>
* @author <a href="mailto:monroe@dukece.com>Greg Monroe</a>
* @version $Id: Column.java 476581 2006-11-18 18:14:14Z tv $
*/
public class Column
{
private static final SchemaType DEFAULT_TYPE = SchemaType.VARCHAR;
/** Logging class from commons.logging */
private static Log log = LogFactory.getLog(Column.class);
private String name;
private String description;
private Domain domain = new Domain();
private String javaName = null;
private String javaNamingMethod;
private boolean isNotNull = false;
private boolean isProtected = false;
private String javaType;
private Table parentTable;
private int position;
private boolean isPrimaryKey = false;
private boolean isUnique = false;
private boolean isAutoIncrement = false;
private List referrers;
// only one type is supported currently, which assumes the
// column either contains the classnames or a key to
// classnames specified in the schema. Others may be
// supported later.
private String inheritanceType;
private boolean isInheritance;
private boolean isEnumeratedClasses;
private List inheritanceList;
private boolean needsTransactionInPostgres;
/** generate is... setters for boolean columns if true */
private boolean correctGetters = false;
/** class name to do input validation on this column */
private String inputValidator = null;
private Map options;
/**
* Creates a new instance with a <code>null</code> name.
*/
public Column()
{
this(null);
}
/**
* Creates a new column and set the name
*
* @param name column name
*/
public Column(String name)
{
this.name = name;
options = Collections.synchronizedMap(new ListOrderedMap());
}
/**
* Return a comma delimited string listing the specified columns.
*
* @param columns Either a list of <code>Column</code> objects, or
* a list of <code>String</code> objects with column names.
*/
public static String makeList(List columns)
{
Object obj = columns.get(0);
boolean isColumnList = (obj instanceof Column);
if (isColumnList)
{
obj = ((Column) obj).getName();
}
StringBuffer buf = new StringBuffer((String) obj);
for (int i = 1; i < columns.size(); i++)
{
obj = columns.get(i);
if (isColumnList)
{
obj = ((Column) obj).getName();
}
buf.append(", ").append(obj);
}
return buf.toString();
}
/**
* Imports a column from an XML specification
*/
public void loadFromXML(Attributes attrib)
{
String dom = attrib.getValue("domain");
if (StringUtils.isNotEmpty(dom))
{
domain = new Domain(getTable().getDatabase().getDomain(dom));
}
else
{
domain = new Domain(getPlatform().getDomainForSchemaType(DEFAULT_TYPE));
setType(attrib.getValue("type"));
}
//Name
name = attrib.getValue("name");
javaName = attrib.getValue("javaName");
javaType = attrib.getValue("javaType");
if (javaType != null && javaType.length() == 0)
{
javaType = null;
}
// retrieves the method for converting from specified name to
// a java name.
javaNamingMethod = attrib.getValue("javaNamingMethod");
if (javaNamingMethod == null)
{
javaNamingMethod
= parentTable.getDatabase().getDefaultJavaNamingMethod();
}
//Primary Key
String primaryKey = attrib.getValue("primaryKey");
//Avoid NullPointerExceptions on string comparisons.
isPrimaryKey = ("true".equals(primaryKey));
// If this column is a primary key then it can't be null.
if ("true".equals(primaryKey))
{
isNotNull = true;
}
// HELP: Should primary key, index, and/or idMethod="native"
// affect isNotNull? If not, please document why here.
String notNull = attrib.getValue("required");
isNotNull = (notNull != null && "true".equals(notNull));
//AutoIncrement/Sequences
String autoIncrement = attrib.getValue("autoIncrement");
// autoincrement is false per default,
// except if the column is a primary key
// and the idMethod is native
// and the platform's default id Method is identity
// and autoIncrement is not excplicitly set to false
isAutoIncrement = ("true".equals(autoIncrement)
|| (isPrimaryKey()
&& IDMethod.NATIVE.equals(getTable().getIdMethod())
&& Platform.IDENTITY.equals(
getPlatform().getNativeIdMethod())
&& (!"false".equals(autoIncrement))));
//Default column value.
domain.replaceDefaultValue(attrib.getValue("default"));
domain.replaceSize(attrib.getValue("size"));
domain.replaceScale(attrib.getValue("scale"));
inheritanceType = attrib.getValue("inheritance");
isInheritance = (inheritanceType != null
&& !inheritanceType.equals("false"));
this.inputValidator = attrib.getValue("inputValidator");
description = attrib.getValue("description");
isProtected = ("true".equals(attrib.getValue("protected")));
}
/**
* Returns table.column
*/
public String getFullyQualifiedName()
{
return (parentTable.getName() + '.' + name);
}
/**
* Get the name of the column
*/
public String getName()
{
return name;
}
/**
* Set the name of the column
*/
public void setName(String newName)
{
name = newName;
}
/**
* Get the description for the Table
*/
public String getDescription()
{
return description;
}
/**
* Set the description for the Table
*
* @param newDescription description for the Table
*/
public void setDescription(String newDescription)
{
description = newDescription;
}
/**
* Get name to use in Java sources to build method names.
*
* @return the capitalised javaName
*/
public String getJavaName()
{
if (javaName == null)
{
List inputs = new ArrayList(2);
inputs.add(name);
inputs.add(javaNamingMethod);
try
{
javaName = NameFactory.generateName(NameFactory.JAVA_GENERATOR,
inputs);
}
catch (EngineException e)
{
log.error(e, e);
}
}
return StringUtils.capitalize(javaName);
}
/**
* Returns the name for the getter method to retrieve the value of this
* column
*
* @return A getter method name for this column.
* @since 3.2
*/
public String getGetterName()
{
if (("boolean".equalsIgnoreCase(getJavaNative()) && isCorrectGetters()))
{
return "is" + StringUtils.capitalize(getJavaName());
}
else
{
return "get" + StringUtils.capitalize(getJavaName());
}
}
/**
* Returns the name for the setter method to set the value of this
* column
*
* @return A setter method name for this column.
* @since 3.2
*/
public String getSetterName()
{
return "set" + StringUtils.capitalize(getJavaName());
}
/**
* Get variable name to use in Java sources (= uncapitalised java name)
*/
public String getUncapitalisedJavaName()
{
return StringUtils.uncapitalize(getJavaName());
}
/**
* Returns the name of the constant that is used for the column in the Peer
* class, e.g., RecordPeer.COLVARNAME.
* Generally this will be a straight conversion to upper case.
* But if the column name is equals to TABLE_NAME or
* DATABASE_NAME (Torque predefined vars), the column name will have an _
* prefixed, e.g. _TABLE_NAME.
* <p>
* TODO: Handle delimited column names that have non-Java identifier
* characters in them.
*
* @return The name to use in defining the Peer class column variable.
*/
public String getPeerJavaName()
{
String peerName = name.toUpperCase();
if ( peerName.equals("TABLE_NAME") ||
peerName.equals("DATABASE_NAME")) {
peerName = "_" + peerName;
}
return peerName;
}
/**
* Set the name to use in Java sources.
*/
public void setJavaName(String javaName)
{
this.javaName = javaName;
}
/**
* Returns whether the type in the java object should be an object
* or primitive.
*/
public String getJavaType()
{
return javaType;
}
/**
* Get the location of this column within the table (one-based).
* @return value of position.
*/
public int getPosition()
{
return position;
}
/**
* Get the location of this column within the table (one-based).
* @param v Value to assign to position.
*/
public void setPosition(int v)
{
this.position = v;
}
/**
* Set the parent Table of the column
*/
public void setTable(Table parent)
{
parentTable = parent;
}
/**
* Get the parent Table of the column
*/
public Table getTable()
{
return parentTable;
}
/**
* Returns the Name of the table the column is in
*/
public String getTableName()
{
return parentTable.getName();
}
/**
* A utility function to create a new column
* from attrib and add it to this table.
*/
public Inheritance addInheritance(Attributes attrib)
{
Inheritance inh = new Inheritance();
inh.loadFromXML (attrib);
addInheritance(inh);
return inh;
}
/**
* Adds a new inheritance definition to the inheritance list and set the
* parent column of the inheritance to the current column
*/
public void addInheritance(Inheritance inh)
{
inh.setColumn(this);
if (inheritanceList == null)
{
inheritanceList = new ArrayList();
isEnumeratedClasses = true;
}
inheritanceList.add(inh);
}
/**
* Get the inheritance definitions.
*/
public List getChildren()
{
return inheritanceList;
}
/**
* Determine if this column is a normal property or specifies a
* the classes that are represented in the table containing this column.
*/
public boolean isInheritance()
{
return isInheritance;
}
/**
* Determine if possible classes have been enumerated in the xml file.
*/
public boolean isEnumeratedClasses()
{
return isEnumeratedClasses;
}
/**
* Return the isNotNull property of the column
*/
public boolean isNotNull()
{
return isNotNull;
}
/**
* Set the isNotNull property of the column
*/
public void setNotNull(boolean status)
{
isNotNull = status;
}
/**
* Return NOT NULL String for this column
*
* @return "NOT NULL" if null values are not allowed or an empty String.
*/
public String getNotNullString()
{
return getTable().getDatabase().getPlatform()
.getNullString(this.isNotNull());
}
/**
* Return the isProtected property of the column
*/
public boolean isProtected()
{
return isProtected;
}
/**
* Set the isProtected property of the Column
*/
public void setProtected(boolean prot)
{
isProtected = prot;
}
/**
* Set if the column is a primary key or not
*/
public void setPrimaryKey(boolean pk)
{
isPrimaryKey = pk;
}
/**
* Return true if the column is a primary key
*/
public boolean isPrimaryKey()
{
return isPrimaryKey;
}
/**
* Set true if the column is UNIQUE
*/
public void setUnique (boolean u)
{
isUnique = u;
}
/**
* Get the UNIQUE property
*/
public boolean isUnique()
{
return isUnique;
}
/**
* Return true if the column requires a transaction in Postgres
*/
public boolean requiresTransactionInPostgres()
{
return needsTransactionInPostgres;
}
/**
* Utility method to determine if this column is a foreign key.
*/
public boolean isForeignKey()
{
return (getForeignKey() != null);
}
/**
* Determine if this column is a foreign key that refers to the
* same table as another foreign key column in this table.
*/
public boolean isMultipleFK()
{
ForeignKey fk = getForeignKey();
if (fk != null)
{
Iterator fks = parentTable.getForeignKeys().iterator();
while (fks.hasNext())
{
ForeignKey key = (ForeignKey) fks.next();
if (key.getForeignTableName().equals(fk.getForeignTableName())
&& !key.getLocalColumns().contains(this.name))
{
return true;
}
}
}
// No multiple foreign keys.
return false;
}
/**
* get the foreign key object for this column
* if it is a foreign key or part of a foreign key
*/
public ForeignKey getForeignKey()
{
return parentTable.getForeignKey(this.name);
}
/**
* Utility method to get the related table of this column if it is a foreign
* key or part of a foreign key
*/
public String getRelatedTableName()
{
ForeignKey fk = getForeignKey();
return (fk == null ? null : fk.getForeignTableName());
}
/**
* Utility method to get the related column of this local column if this
* column is a foreign key or part of a foreign key.
*/
public String getRelatedColumnName()
{
ForeignKey fk = getForeignKey();
if (fk == null)
{
return null;
}
else
{
return fk.getLocalForeignMapping().get(this.name).toString();
}
}
/**
* Adds the foreign key from another table that refers to this column.
*/
public void addReferrer(ForeignKey fk)
{
if (referrers == null)
{
referrers = new ArrayList(5);
}
referrers.add(fk);
}
/**
* Get list of references to this column.
*/
public List getReferrers()
{
if (referrers == null)
{
referrers = new ArrayList(5);
}
return referrers;
}
/**
* Sets the colunm type
*/
public void setType(String torqueType)
{
SchemaType type = SchemaType.getEnum(torqueType);
if (type == null)
{
log.warn("SchemaType " + torqueType + " does not exist");
type = Column.DEFAULT_TYPE;
}
setType(type);
}
/**
* Sets the colunm type
*/
public void setType(SchemaType torqueType)
{
domain = new Domain(getPlatform().getDomainForSchemaType(torqueType));
if (torqueType.equals(SchemaType.VARBINARY)
|| torqueType.equals(SchemaType.BLOB))
{
needsTransactionInPostgres = true;
}
}
/**
* Returns the column jdbc type as an object
*
* @deprecated the type conversion is handled by the platform package
* (since torque 3.2)
*/
public Object getType()
{
return TypeMap.getJdbcType(domain.getType()).getName();
}
/**
* Returns the column type as given in the schema as an object
*/
public Object getTorqueType()
{
return domain.getType().getName();
}
/**
* Utility method to see if the column is a string
*
* @deprecated will be removed after the 3.3 release
*/
public boolean isString()
{
return (domain.getType().getName().indexOf ("CHAR") != -1);
}
/**
* Utility method to return the value as an element to be usable
* in an SQL insert statement. This is used from the SQL loader task
*/
public boolean needEscapedValue()
{
String torqueType = domain.getType().getName();
return (torqueType != null) && (torqueType.equals("VARCHAR")
|| torqueType.equals("LONGVARCHAR")
|| torqueType.equals("DATE")
|| torqueType.equals("DATETIME")
|| torqueType.equals("TIMESTAMP")
|| torqueType.equals("TIME")
|| torqueType.equals("CHAR")
|| torqueType.equals("CLOB"));
}
/**
* String representation of the column. This is an xml representation.
*
* @return string representation in xml
*/
public String toString()
{
StringBuffer result = new StringBuffer();
result.append(" <column name=\"").append(name).append('"');
if (javaName != null)
{
result.append(" javaName=\"").append(javaName).append('"');
}
if (isPrimaryKey)
{
result.append(" primaryKey=\"").append(isPrimaryKey).append('"');
}
if (isNotNull)
{
result.append(" required=\"true\"");
}
else
{
result.append(" required=\"false\"");
}
result.append(" type=\"").append(domain.getType().getName()).append('"');
if (domain.getSize() != null)
{
result.append(" size=\"").append(domain.getSize()).append('"');
}
if (domain.getScale() != null)
{
result.append(" scale=\"").append(domain.getScale()).append('"');
}
if (domain.getDefaultValue() != null)
{
result.append(" default=\"").append(domain.getDefaultValue()).append('"');
}
if (isInheritance())
{
result.append(" inheritance=\"").append(inheritanceType)
.append('"');
}
// Close the column.
result.append(" />\n");
return result.toString();
}
/**
* Returns the size of the column
*/
public String getSize()
{
return domain.getSize();
}
/**
* Set the size of the column
*/
public void setSize(String newSize)
{
domain.setSize(newSize);
}
/**
* Try to determine the precision of the field from the size attribute.
* If size attribute is an integer number, it will be returned.
* If size attribute is of the format "Precision,Scale", then Precision
* will be returned.
* If size is null or the size value is not an valid integer,
* null is returned.
* <p>
* Note: Unparseable values will be logged as a warning.
*
* @return The precision portion of the size attribute.
*/
public String getPrecision()
{
String size = getSize();
if ( size == null )
{
return size;
}
int cLoc = size.indexOf(',');
if ( cLoc > 0 )
{
size = size.substring(0, cLoc);
}
try
{
Integer.parseInt(size);
}
catch ( NumberFormatException e )
{
log.warn("getPrecision(): Size attribute found ("
+ getSize()
+ ") was not an integer number, using default of null!");
size = null;
}
return size;
}
/**
* Try to determine the scale of the field from the scale and size
* attribute.
* If scale attribute is an integer number, it will be returned.
* If size attribute is of the format "Precision,Scale", then Scale
* will be returned.
* If scale and size attributes are null or the scale value found
* is not an valid integer, a null value is returned.
* <p>
* Note: Unparseable values will be logged as a warning.
*
* @return The precision portion of the size attribute.
*/
public String getScale()
{
String scale = domain.getScale();
// Check for scale on size attribute if no scale attribute
if ( scale == null )
{
scale = getSize();
if ( scale == null ) // No scale or size attribute set.
{
return scale;
}
int cLoc = scale.indexOf(',');
if ( cLoc < 0 ) // Size did not have "P,S" format
{
return null;
}
scale = scale.substring(cLoc + 1 );
}
// Validate that scale string found is integer.
try
{
Integer.parseInt(scale);
}
catch ( NumberFormatException e )
{
log.warn("getScale(): Scale (or size=\"p,s\") attribute found ("
+ scale
+ ") was not an integer number, using default of null.");
scale = null;
}
return scale;
}
/**
* Set the scale of the column
*/
public void setScale(String newScale)
{
domain.setScale(newScale);
}
/**
* Return the size and scale in brackets for use in an sql schema.
*
* @return size and scale or an empty String if there are no values
* available.
*/
public String printSize()
{
return domain.printSize();
}
/**
* Return a string that will give this column a default value.
* @deprecated
*/
public String getDefaultSetting()
{
return domain.getDefaultSetting();
}
/**
* Set a string that will give this column a default value.
*/
public void setDefaultValue(String def)
{
domain.setDefaultValue(def);
}
/**
* Get a string that will give this column a default value.
*/
public String getDefaultValue()
{
return domain.getDefaultValue();
}
/**
* Returns the class name to do input validation
*/
public String getInputValidator()
{
return this.inputValidator;
}
/**
* Return auto increment/sequence string for the target database. We need to
* pass in the props for the target database!
*/
public boolean isAutoIncrement()
{
return isAutoIncrement;
}
/**
* Set the auto increment value.
* Use isAutoIncrement() to find out if it is set or not.
*/
public void setAutoIncrement(boolean value)
{
isAutoIncrement = value;
}
public String getAutoIncrementString()
{
if (isAutoIncrement()
&& IDMethod.NATIVE.equals(getTable().getIdMethod()))
{
return getPlatform().getAutoIncrement();
}
return "";
}
/**
* Set the column type from a string property
* (normally a string from an sql input file)
*/
public void setTypeFromString(String typeName, String size)
{
String tn = typeName.toUpperCase();
setType(tn);
if (size != null)
{
domain.setSize(size);
}
if (tn.indexOf("CHAR") != -1)
{
domain.setType(SchemaType.VARCHAR);
}
else if (tn.indexOf("INT") != -1)
{
domain.setType(SchemaType.INTEGER);
}
else if (tn.indexOf("FLOAT") != -1)
{
domain.setType(SchemaType.FLOAT);
}
else if (tn.indexOf("DATE") != -1)
{
domain.setType(SchemaType.DATE);
}
else if (tn.indexOf("TIME") != -1)
{
domain.setType(SchemaType.TIMESTAMP);
}
else if (tn.indexOf("BINARY") != -1)
{
domain.setType(SchemaType.LONGVARBINARY);
}
else
{
domain.setType(SchemaType.VARCHAR);
}
}
/**
* Return a string representation of the
* Java object which corresponds to the JDBC
* type of this column. Use in the generation
* of MapBuilders.
*/
public String getJavaObject()
{
return TypeMap.getJavaObject(domain.getType());
}
/**
* Return a string representation of the primitive java type which
* corresponds to the JDBC type of this column.
*
* @return string representation of the primitive java type
*/
public String getJavaPrimitive()
{
return TypeMap.getJavaNative(domain.getType());
}
/**
* Return a string representation of the native java type which corresponds
* to the JDBC type of this column. Use in the generation of Base objects.
* This method is used by torque, so it returns Key types for primaryKey and
* foreignKey columns
*
* @return java datatype used by torque
*/
public String getJavaNative()
{
String jtype = TypeMap.getJavaNativeObject(domain.getType());
if (isUsePrimitive())
{
jtype = TypeMap.getJavaNative(domain.getType());
}
return jtype;
}
/**
* Return Village asX() method which corresponds to the JDBC type
* which represents this column.
*/
public String getVillageMethod()
{
String vmethod = TypeMap.getVillageObjectMethod(domain.getType());
if (isUsePrimitive())
{
vmethod = TypeMap.getVillageMethod(domain.getType());
}
return vmethod;
}
/**
* Return ParameterParser getX() method which
* corresponds to the JDBC type which represents this column.
*/
public String getParameterParserMethod()
{
return TypeMap.getPPMethod(domain.getType());
}
/**
* Returns true if the column type is boolean in the
* java object and a numeric (1 or 0) in the db.
*/
public boolean isBooleanInt()
{
return TypeMap.isBooleanInt(domain.getType());
}
/**
* Returns true if the column type is boolean in the
* java object and a String ("Y" or "N") in the db.
*/
public boolean isBooleanChar()
{
return TypeMap.isBooleanChar(domain.getType());
}
/**
* Returns true if the column type is boolean in the
* java object and a Bit ("1" or "0") in the db.
*/
public boolean isBit()
{
return TypeMap.isBit(domain.getType());
}
/**
* returns true, if the columns java native type is an
* boolean, byte, short, int, long, float, double, char
*/
public boolean isPrimitive()
{
String t = getJavaNative();
return "boolean".equals(t)
|| "byte".equals(t)
|| "short".equals(t)
|| "int".equals(t)
|| "long".equals(t)
|| "float".equals(t)
|| "double".equals(t)
|| "char".equals(t);
}
public boolean isUsePrimitive()
{
String s = getJavaType();
return (s != null && s.equals("primitive"))
|| (s == null && !"object".equals(
getTable().getDatabase().getDefaultJavaType()));
}
/**
* @return Returns the domain.
*/
public Domain getDomain()
{
return domain;
}
/**
* @param domain The domain to set.
*/
public void setDomain(Domain domain)
{
this.domain = domain;
}
private Platform getPlatform()
{
try
{
return getTable().getDatabase().getPlatform();
}
catch (Exception ex)
{
log.warn("could not load platform implementation");
}
return new PlatformDefaultImpl();
}
public String getSqlString()
{
List resultList = new ArrayList();
resultList.add(getName());
String type = getDomain().getSqlType();
if (getPlatform().hasSize(getDomain().getSqlType()))
{
type += getDomain().printSize();
}
resultList.add(type);
if (StringUtils.isNotEmpty(getDomain().getDefaultValue()))
{
resultList.add("default");
if (TypeMap.isTextType(getDomain().getType()))
{
// TODO: Properly SQL-escape the text.
resultList.add(
new StringBuffer()
.append('\'')
.append(getDefaultValue())
.append('\''));
}
else
{
resultList.add(getDefaultValue());
}
}
if (getPlatform().createNotNullBeforeAutoincrement())
{
if (StringUtils.isNotEmpty(getNotNullString()))
{
resultList.add(getNotNullString());
}
}
if (StringUtils.isNotEmpty(getAutoIncrementString()))
{
resultList.add(getAutoIncrementString());
}
if (!getPlatform().createNotNullBeforeAutoincrement())
{
if (StringUtils.isNotEmpty(getNotNullString()))
{
resultList.add(getNotNullString());
}
}
return StringUtils.join(resultList.iterator(), ' ');
}
/**
* Return the correctGetters property of the column
*
* @return The currentValue of the correctGetters property.
* @since 3.2
*/
public boolean isCorrectGetters()
{
return correctGetters;
}
/**
* Set the correctGetters property of the column. If set to true, the
* column returns is<xxx> as the getter name which is correct for the
* Bean Specs but incompatible to pre-3.2 releases.
*
* @param correctGetters The new value of the correctGetters property.
* @since 3.2
*/
public void setCorrectGetters(boolean correctGetters)
{
this.correctGetters = correctGetters;
}
/**
* Get the value of the inheritance attribute defined in the schema XML.
*
* @return Returns the inheritanceType.
*/
public String getInheritanceType()
{
return inheritanceType;
}
/**
* Add an XML Specified option key/value pair to this element's option set.
*
* @param key the key of the option.
* @param value the value of the option.
*/
public void addOption(String key, String value)
{
options.put( key, value );
}
/**
* Get the value that was associated with this key in an XML option
* element.
*
* @param key the key of the option.
* @return The value for the key or a null.
*/
public String getOption(String key)
{
return (String) options.get(key);
}
/**
* Gets the full ordered hashtable array of items specified by XML option
* statements under this element.<p>
*
* Note, this is not thread save but since it's only used for
* generation which is single threaded, there should be minimum
* danger using this in Velocity.
*
* @return An Map of all options. Will not be null but may be empty.
*/
public Map getOptions()
{
return options;
}
}