public SimpleValue() 
{

}

 public SimpleValue(Table table) 
{
		this.table = table;
}

 public Object accept(ValueVisitor visitor) 
{
		return visitor.accept(this);
}

 public  void addColumn(Column column) 
{
		if ( !columns.contains(column) ) columns.add(column);
		column.setValue(this);
		column.setTypeIndex( columns.size()-1 );
}

 public  void addFormula(Formula formula) 
{
		columns.add(formula);
}

 public  void createForeignKey() throws MappingException 
{

}

 public  void createForeignKeyOfEntity(String entityName) 
{
		if ( !hasFormula() && !"none".equals(getForeignKeyName())) {
			ForeignKey fk = table.createForeignKey( getForeignKeyName(), getConstraintColumns(), entityName );
			fk.setCascadeDeleteEnabled(cascadeDeleteEnabled);
		}
}

 public IdentifierGenerator createIdentifierGenerator(Dialect dialect,
    String defaultCatalog,
    String defaultSchema,
    RootClass rootClass) throws MappingException 
{
		
		Properties params = new Properties();
		//if the hibernate-mapping did not specify a schema/catalog, use the defaults
		//specified by properties - but note that if the schema/catalog were specified
		//in hibernate-mapping, or as params, they will already be initialized and
		//will override the values set here (they are in identifierGeneratorProperties)
		if ( defaultSchema!=null ) {
			params.setProperty(PersistentIdentifierGenerator.SCHEMA, defaultSchema);
		}
		if ( defaultCatalog!=null ) {
			params.setProperty(PersistentIdentifierGenerator.CATALOG, defaultCatalog);
		}
		//pass the entity-name, if not a collection-id
		if (rootClass!=null) {
			params.setProperty( IdentifierGenerator.ENTITY_NAME, rootClass.getEntityName() );
		}
		//init the table here instead of earlier, so that we can get a quoted table name
		//TODO: would it be better to simply pass the qualified table name, instead of
		//      splitting it up into schema/catalog/table names
		String tableName = getTable().getQuotedName(dialect);
		params.setProperty( PersistentIdentifierGenerator.TABLE, tableName );
		//pass the column name (a generated id almost always has a single column)
		String columnName = ( (Column) getColumnIterator().next() ).getQuotedName(dialect);
		params.setProperty( PersistentIdentifierGenerator.PK, columnName );
		if (rootClass!=null) {
			StringBuffer tables = new StringBuffer();
			Iterator iter = rootClass.getIdentityTables().iterator();
			while ( iter.hasNext() ) {
				Table table= (Table) iter.next();
				tables.append( table.getQuotedName(dialect) );
				if ( iter.hasNext() ) tables.append(", ");
			}
			params.setProperty( PersistentIdentifierGenerator.TABLES, tables.toString() );
		}
		else {
			params.setProperty( PersistentIdentifierGenerator.TABLES, tableName );
		}
		if (identifierGeneratorProperties!=null) {
			params.putAll(identifierGeneratorProperties);
		}
		return IdentifierGeneratorFactory.create(
				identifierGeneratorStrategy,
				getType(),
				params,
				dialect
			);
}

 public boolean[] getColumnInsertability() 
{
		boolean[] result = new boolean[ getColumnSpan() ];
		int i = 0;
		Iterator iter = getColumnIterator();
		while ( iter.hasNext() ) {
			Selectable s = (Selectable) iter.next();
			result[i++] = !s.isFormula();
		}
		return result;
}

 public Iterator getColumnIterator() 
{
		return columns.iterator();
}

 public int getColumnSpan() 
{
		return columns.size();
}

 public boolean[] getColumnUpdateability() 
{
		return getColumnInsertability();
}

 public List getConstraintColumns() 
{
		return columns;
}

 public FetchMode getFetchMode() 
{
		return FetchMode.SELECT;
}

 public String getForeignKeyName() 
{
		return foreignKeyName;
}

 public Properties getIdentifierGeneratorProperties() 
{
		return identifierGeneratorProperties;
}

 public String getIdentifierGeneratorStrategy() 
{
		return identifierGeneratorStrategy;
}

Returns the identifierGeneratorStrategy.

 public String getNullValue() 
{
		return nullValue;
}

 public Table getTable() 
{
		return table;
}

 public Type getType() throws MappingException 
{
		if (typeName==null) {
			throw new MappingException("No type name");
		}
		Type result = TypeFactory.heuristicType(typeName, typeParameters);
		if (result==null) {
			String msg = "Could not determine type for: " + typeName;
			if(table != null){
				msg += ", at table: " + table.getName();
			}
			if(columns!=null && columns.size() >0) {
				msg += ", for columns: " + columns;
			}
			throw new MappingException(msg);
		}
		return result;
}

 public String getTypeName() 
{
		return typeName;
}

 public Properties getTypeParameters() 
{
		return typeParameters;
}

 public boolean hasFormula() 
{
		Iterator iter = getColumnIterator();
		while ( iter.hasNext() ) {
			Object o = iter.next();
			if (o instanceof Formula) return true;
		}
		return false;
}

 public boolean isAlternateUniqueKey() 
{
		return alternateUniqueKey;
}

 public boolean isCascadeDeleteEnabled() 
{
	   
		return cascadeDeleteEnabled;
}

 public boolean isIdentityColumn(Dialect dialect) 
{
		return IdentifierGeneratorFactory.getIdentifierGeneratorClass(identifierGeneratorStrategy, dialect)
				.equals(IdentityGenerator.class);
}

 public boolean isNullable() 
{
		if ( hasFormula() ) return true;
		boolean nullable = true;
		Iterator iter = getColumnIterator();
		while ( iter.hasNext() ) {
			if ( !( (Column) iter.next() ).isNullable() ) {
				nullable = false;
				return nullable; //shortcut
			}
		}
		return nullable;
}

 public boolean isSimpleValue() 
{
		return true;
}

 public boolean isTypeSpecified() 
{
		return typeName!=null;
}

 public boolean isUpdateable() 
{
		//needed to satisfy KeyValue
		return true;
}

 public boolean isValid(Mapping mapping) throws MappingException 
{
		return getColumnSpan()==getType().getColumnSpan(mapping);
}

 public  void setAlternateUniqueKey(boolean unique) 
{
		this.alternateUniqueKey = unique;
}

 public  void setCascadeDeleteEnabled(boolean cascadeDeleteEnabled) 
{
		this.cascadeDeleteEnabled = cascadeDeleteEnabled;
}

 public  void setForeignKeyName(String foreignKeyName) 
{
		this.foreignKeyName = foreignKeyName;
}

 public  void setIdentifierGeneratorProperties(Properties identifierGeneratorProperties) 
{
		this.identifierGeneratorProperties = identifierGeneratorProperties;
}

Sets the identifierGeneratorProperties.

 public  void setIdentifierGeneratorStrategy(String identifierGeneratorStrategy) 
{
		this.identifierGeneratorStrategy = identifierGeneratorStrategy;
}

Sets the identifierGeneratorStrategy.

 public  void setNullValue(String nullValue) 
{
		this.nullValue = nullValue;
}

Sets the nullValue.

 public  void setTable(Table table) 
{
		this.table = table;
}

 public  void setTypeName(String type) 
{
		this.typeName = type;
}

 public  void setTypeParameters(Properties parameterMap) 
{
		this.typeParameters = parameterMap;
}

 public  void setTypeUsingReflection(String className,
    String propertyName) throws MappingException 
{
		if (typeName==null) {
			if (className==null) {
				throw new MappingException("you must specify types for a dynamic entity: " + propertyName);
			}
			typeName = ReflectHelper.reflectedPropertyClass(className, propertyName).getName();
		}
}

 public String toString() 
{
		return getClass().getName() + '(" + columns.toString() + ')";
}