abstract public Object accept(PersistentClassVisitor mv)

 public  void addFilter(String name,
    String condition) 
{
		filters.put(name, condition);
}

 public  void addJoin(Join join) 
{
		joins.add(join);
		join.setPersistentClass(this);
}

 public  void addProperty(Property p) 
{
		properties.add(p);
		p.setPersistentClass(this);
}

 public  void addSubclass(Subclass subclass) throws MappingException 
{
		// inheritance cycle detection (paranoid check)
		PersistentClass superclass = getSuperclass();
		while (superclass!=null) {
			if( subclass.getEntityName().equals( superclass.getEntityName() ) ) {
				throw new MappingException(
					"Circular inheritance mapping detected: " +
					subclass.getEntityName() +
					" will have it self as superclass when extending " +
					getEntityName()
				);
			}
			superclass = superclass.getSuperclass();
		}
		subclasses.add(subclass);
}

 protected  void addSubclassJoin(Join join) 
{
		subclassJoins.add(join);
}

 protected  void addSubclassProperty(Property prop) 
{
		subclassProperties.add(prop);
}

 protected  void addSubclassTable(Table subclassTable) 
{
		subclassTables.add(subclassTable);
}

 public  void addSynchronizedTable(String table) 
{
		synchronizedTables.add(table);
}

 public  void addTuplizer(EntityMode entityMode,
    String implClassName) 
{
		if ( tuplizerImpls == null ) {
			tuplizerImpls = new HashMap();
		}
		tuplizerImpls.put( entityMode, implClassName );
}

 protected  void checkColumnDuplication() 
{
		HashSet cols = new HashSet();
		checkColumnDuplication( cols, getKey().getColumnIterator() );
		checkColumnDuplication( cols, getDiscriminatorColumnIterator() );
		checkPropertyColumnDuplication( cols, getNonDuplicatedPropertyIterator() );
		Iterator iter = getJoinIterator();
		while ( iter.hasNext() ) {
			cols.clear();
			Join join = (Join) iter.next();
			checkColumnDuplication( cols, join.getKey().getColumnIterator() );
			checkPropertyColumnDuplication( cols, join.getPropertyIterator() );
		}
}

 protected  void checkColumnDuplication(Set distinctColumns,
    Iterator columns) throws MappingException 
{
		while ( columns.hasNext() ) {
			Selectable columnOrFormula = (Selectable) columns.next();
			if ( !columnOrFormula.isFormula() ) {
				Column col = (Column) columnOrFormula;
				if ( !distinctColumns.add( col.getName() ) ) {
					throw new MappingException( 
							"Repeated column in mapping for entity: " +
							getEntityName() +
							" column: " +
							col.getName() + 
							" (should be mapped with insert=\"false\" update=\"false\")"
						);
				}
			}
		}
}

 protected  void checkPropertyColumnDuplication(Set distinctColumns,
    Iterator properties) throws MappingException 
{
		while ( properties.hasNext() ) {
			Property prop = (Property) properties.next();
			if ( prop.getValue() instanceof Component ) { //TODO: remove use of instanceof!
				Component component = (Component) prop.getValue();
				checkPropertyColumnDuplication( distinctColumns, component.getPropertyIterator() );
			}
			else {
				if ( prop.isUpdateable() || prop.isInsertable() ) {
					checkColumnDuplication( distinctColumns, prop.getColumnIterator() );
				}
			}
		}
}

 public  void createPrimaryKey() 
{
		//Primary key constraint
		PrimaryKey pk = new PrimaryKey();
		Table table = getTable();
		pk.setTable(table);
		pk.setName( PK_ALIAS.toAliasString( table.getName() ) );
		table.setPrimaryKey(pk);
		pk.addColumns( getKey().getColumnIterator() );
}

 public int getBatchSize() 
{
		return batchSize;
}

 abstract public String getCacheConcurrencyStrategy()

 public String getClassName() 
{
	   
		return className;
}

 public String getCustomSQLDelete() 
{
		return customSQLDelete;
}

 public String getCustomSQLInsert() 
{
		return customSQLInsert;
}

 public String getCustomSQLUpdate() 
{
		return customSQLUpdate;
}

 public Iterator getDirectSubclasses() 
{
		return subclasses.iterator();
}

 abstract public Value getDiscriminator()

 protected Iterator getDiscriminatorColumnIterator() 
{
		return EmptyIterator.INSTANCE;
}

 public String getDiscriminatorValue() 
{
		return discriminatorValue;
}

 public String getEntityName() 
{
		return entityName;
}

 abstract public Class getEntityPersisterClass()

 public Map getFilterMap() 
{
		return filters;
}

 abstract public KeyValue getIdentifier()

 public Component getIdentifierMapper() 
{
		return identifierMapper;
}

 abstract public Property getIdentifierProperty()

 public Table getIdentityTable() 
{
		return getRootTable();
}

 public Iterator getJoinClosureIterator() 
{
		return joins.iterator();
}

 public int getJoinClosureSpan() 
{
		return joins.size();
}

 public Iterator getJoinIterator() 
{
		return joins.iterator();
}

 public int getJoinNumber(Property prop) 
{
		int result=1;
		Iterator iter = getSubclassJoinClosureIterator();
		while ( iter.hasNext() ) {
			Join join = (Join) iter.next();
			if ( join.containsProperty(prop) ) return result;
			result++;
		}
		return 0;
}

 abstract public KeyValue getKey()

 abstract public Iterator getKeyClosureIterator()

 public String getLoaderName() 
{
		return loaderName;
}

 public Class getMappedClass() throws MappingException 
{
		if (className==null) return null;
		try {
			return ReflectHelper.classForName(className);
		}
		catch (ClassNotFoundException cnfe) {
			throw new MappingException("entity class not found: " + className, cnfe);
		}
}

 public MetaAttribute getMetaAttribute(String name) 
{
		return metaAttributes==null?null:(MetaAttribute) metaAttributes.get(name);
}

 public Map getMetaAttributes() 
{
		return metaAttributes;
}

 public String getNodeName() 
{
		return nodeName;
}

 protected Iterator getNonDuplicatedPropertyIterator() 
{
		return getUnjoinedPropertyIterator();
}

 abstract public int getOptimisticLockMode()

 public Property getProperty(String propertyName) throws MappingException 
{
		Iterator iter = getPropertyClosureIterator();
		return getProperty( propertyName, iter );
}

 abstract public Iterator getPropertyClosureIterator()

 public int getPropertyClosureSpan() 
{
		int span = properties.size();
		for ( int i=0; i< joins.size(); i++ ) {
			Join join = (Join) joins.get(i);
			span += join.getPropertySpan();
		}
		return span;
}

 public Iterator getPropertyIterator() 
{
		ArrayList iterators = new ArrayList();
		iterators.add( properties.iterator() );
		for ( int i=0; i< joins.size(); i++ ) {
			Join join = (Join) joins.get(i);
			iterators.add( join.getPropertyIterator() );
		}
		return new JoinedIterator(iterators);
}

 public Class getProxyInterface() 
{
		if (proxyInterfaceName==null) return null;
		try {
			return ReflectHelper.classForName(proxyInterfaceName);
		}
		catch (ClassNotFoundException cnfe) {
			throw new MappingException("proxy class not found: " + proxyInterfaceName, cnfe);
		}
}

 public String getProxyInterfaceName() 
{
		return proxyInterfaceName;
}

 public Property getRecursiveProperty(String propertyPath) throws MappingException 
{
		Iterator iter = getPropertyIterator(); //  getReferenceablePropertyIterator();
		try {
			return getRecursiveProperty( propertyPath, iter );
		}
		catch (MappingException e) {
			throw new MappingException(
					"property not found: " + propertyPath +
					"in entity: " + getEntityName(), e
				);
		}
}

 public Iterator getReferenceablePropertyIterator() 
{
		return getPropertyClosureIterator();
}

 public Property getReferencedProperty(String propertyPath) throws MappingException 
{
		Iterator iter = getReferenceablePropertyIterator();
		try {
			return getRecursiveProperty( propertyPath, iter );
		}
		catch (MappingException e) {
			throw new MappingException(
					"property-ref not found: " + propertyPath +
					"in entity: " + getEntityName(), e
				);
		}
}

 abstract public RootClass getRootClass()

 abstract public Table getRootTable()

 public Iterator getSubclassClosureIterator() 
{
		ArrayList iters = new ArrayList();
		iters.add( new SingletonIterator(this) );
		Iterator iter = getSubclassIterator();
		while ( iter.hasNext() ) {
			PersistentClass clazz = (PersistentClass)  iter.next();
			iters.add( clazz.getSubclassClosureIterator() );
		}
		return new JoinedIterator(iters);
}

 abstract public int getSubclassId()

 public Iterator getSubclassIterator() 
{
		Iterator[] iters = new Iterator[ subclasses.size() + 1 ];
		Iterator iter = subclasses.iterator();
		int i=0;
		while ( iter.hasNext() ) {
			iters[i++] = ( (Subclass) iter.next() ).getSubclassIterator();
		}
		iters[i] = subclasses.iterator();
		return new JoinedIterator(iters);
}

Iterate over subclasses in a special 'order', most derived subclasses first.

 public Iterator getSubclassJoinClosureIterator() 
{
		return new JoinedIterator( getJoinClosureIterator(), subclassJoins.iterator() );
}

 public Iterator getSubclassPropertyClosureIterator() 
{
		ArrayList iters = new ArrayList();
		iters.add( getPropertyClosureIterator() );
		iters.add( subclassProperties.iterator() );
		for ( int i=0; i< subclassJoins.size(); i++ ) {
			Join join = (Join) subclassJoins.get(i);
			iters.add( join.getPropertyIterator() );
		}
		return new JoinedIterator(iters);
}

 public int getSubclassSpan() 
{
		int n = subclasses.size();
		Iterator iter = subclasses.iterator();
		while ( iter.hasNext() ) {
			n += ( (Subclass) iter.next() ).getSubclassSpan();
		}
		return n;
}

 public Iterator getSubclassTableClosureIterator() 
{
		return new JoinedIterator( getTableClosureIterator(), subclassTables.iterator() );
}

 abstract public PersistentClass getSuperclass()

 abstract public Set getSynchronizedTables()

 abstract public Table getTable()

 abstract public Iterator getTableClosureIterator()

 public String getTemporaryIdTableDDL() 
{
		return temporaryIdTableDDL;
}

 public String getTemporaryIdTableName() 
{
		return temporaryIdTableName;
}

 public String getTuplizerImplClassName(EntityMode mode) 
{
		if ( tuplizerImpls == null ) return null;
		return ( String ) tuplizerImpls.get( mode );
}

 public Iterator getUnjoinedPropertyIterator() 
{
		return properties.iterator();
}

 abstract public Property getVersion()

 abstract public String getWhere()

 public boolean hasDom4jRepresentation() 
{
		return getNodeName()!=null;
}

 abstract public boolean hasEmbeddedIdentifier()

 public boolean hasIdentifierMapper() 
{
		return identifierMapper != null;
}

 abstract public boolean hasIdentifierProperty()

 public boolean hasNaturalId() 
{
		Iterator props = getRootClass().getPropertyIterator();
		while ( props.hasNext() ) {
			if ( ( (Property) props.next() ).isNaturalIdentifier() ) {
				return true;
			}
		}
		return false;
}

 public boolean hasPojoRepresentation() 
{
		return getClassName()!=null;
}

 public boolean hasSelectBeforeUpdate() 
{
		return selectBeforeUpdate;
}

 public boolean hasSubclasses() 
{
		return subclasses.size()  > 0;
}

 public boolean hasSubselectLoadableCollections() 
{
		return hasSubselectLoadableCollections;
}

 public Boolean isAbstract() 
{
		return isAbstract;
}

 public boolean isClassOrSuperclassJoin(Join join) 
{
		return joins.contains(join);
}

 public boolean isClassOrSuperclassTable(Table closureTable) 
{
		return getTable()==closureTable;
}

 public boolean isCustomDeleteCallable() 
{
		return customDeleteCallable;
}

 public boolean isCustomInsertCallable() 
{
		return customInsertCallable;
}

 public boolean isCustomUpdateCallable() 
{
		return customUpdateCallable;
}

 abstract public boolean isDiscriminatorInsertable()

 public boolean isDiscriminatorValueNotNull() 
{
		return NOT_NULL_DISCRIMINATOR_MAPPING.equals( getDiscriminatorValue() );
}

 public boolean isDiscriminatorValueNull() 
{
		return NULL_DISCRIMINATOR_MAPPING.equals( getDiscriminatorValue() );
}

 abstract public boolean isExplicitPolymorphism()

 public boolean isForceDiscriminator() 
{
		return false;
}

 abstract public boolean isInherited()

 abstract public boolean isJoinedSubclass()

 public boolean isLazy() 
{
		return lazy;
}

 abstract public boolean isLazyPropertiesCacheable()

 abstract public boolean isMutable()

 abstract public boolean isPolymorphic()

 abstract public boolean isVersioned()

 abstract int nextSubclassId()

 public  void prepareTemporaryTables(Mapping mapping,
    Dialect dialect) 
{
		if ( dialect.supportsTemporaryTables() ) {
			temporaryIdTableName = dialect.generateTemporaryTableName( getTable().getName() );
			Table table = new Table();
			table.setName( temporaryIdTableName );
			Iterator itr = getTable().getPrimaryKey().getColumnIterator();
			while( itr.hasNext() ) {
				Column column = (Column) itr.next();
				table.addColumn( (Column) column.clone()  );
			}
			temporaryIdTableDDL = table.sqlTemporaryTableCreateString( dialect, mapping );
		}
}

 public  void setAbstract(Boolean isAbstract) 
{
		this.isAbstract = isAbstract;
}

 public  void setBatchSize(int batchSize) 
{
		this.batchSize = batchSize;
}

 public  void setClassName(String className) 
{
		this.className = className==null ? null : className.intern();
}

 public  void setCustomSQLDelete(String customSQLDelete,
    boolean callable) 
{
		this.customSQLDelete = customSQLDelete;
		this.customDeleteCallable = callable;
}

 public  void setCustomSQLInsert(String customSQLInsert,
    boolean callable) 
{
		this.customSQLInsert = customSQLInsert;
		this.customInsertCallable = callable;
}

 public  void setCustomSQLUpdate(String customSQLUpdate,
    boolean callable) 
{
		this.customSQLUpdate = customSQLUpdate;
		this.customUpdateCallable = callable;
}

 public  void setDiscriminatorValue(String discriminatorValue) 
{
		this.discriminatorValue = discriminatorValue;
}

 public  void setDynamicInsert(boolean dynamicInsert) 
{
		this.dynamicInsert = dynamicInsert;
}

 public  void setDynamicUpdate(boolean dynamicUpdate) 
{
		this.dynamicUpdate = dynamicUpdate;
}

 public  void setEntityName(String entityName) 
{
		this.entityName = entityName==null ? null : entityName.intern();
}

 abstract public  void setEntityPersisterClass(Class classPersisterClass)

 public  void setIdentifierMapper(Component handle) 
{
		this.identifierMapper = handle;
}

 public  void setLazy(boolean lazy) 
{
		this.lazy = lazy;
}

 public  void setLoaderName(String loaderName) 
{
		this.loaderName = loaderName==null ? null : loaderName.intern();
}

 public  void setMetaAttributes(Map metas) 
{
		this.metaAttributes = metas;
}

 public  void setNodeName(String nodeName) 
{
		this.nodeName = nodeName;
}

 public  void setOptimisticLockMode(int optimisticLockMode) 
{
		this.optimisticLockMode = optimisticLockMode;
}

 public  void setProxyInterfaceName(String proxyInterfaceName) 
{
		this.proxyInterfaceName = proxyInterfaceName;
}

 public  void setSelectBeforeUpdate(boolean selectBeforeUpdate) 
{
		this.selectBeforeUpdate = selectBeforeUpdate;
}

 public  void setSubselectLoadableCollections(boolean hasSubselectCollections) 
{
		this.hasSubselectLoadableCollections = hasSubselectCollections;
}

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

 public boolean useDynamicInsert() 
{
		return dynamicInsert;
}

 public boolean useDynamicUpdate() 
{
		return dynamicUpdate;
}

 public  void validate(Mapping mapping) throws MappingException 
{
		Iterator iter = getPropertyIterator();
		while ( iter.hasNext() ) {
			Property prop = (Property) iter.next();
			if ( !prop.isValid(mapping) ) {
				throw new MappingException(
						"property mapping has wrong number of columns: " +
						StringHelper.qualify( getEntityName(), prop.getName() ) +
						" type: " +
						prop.getType().getName()
					);
			}
		}
		checkPropertyDuplication();
		checkColumnDuplication();
}