ExtendedMappings(Map classes,
    Map collections,
    Map tables,
    Map queries,
    Map sqlqueries,
    Map sqlResultSetMappings,
    Set defaultNamedQueryNames,
    Set defaultNamedNativeQueryNames,
    Set defaultSqlResulSetMappingNames,
    Set defaultNamedGenerators,
    Map imports,
    List secondPasses,
    List propertyReferences,
    NamingStrategy namingStrategy,
    Map typeDefs,
    Map filterDefinitions,
    Map namedGenerators,
    Map joins,
    Map classTypes,
    Map extendsQueue,
    Map tableNameBinding,
    Map columnNameBindingPerTable,
    List auxiliaryDatabaseObjects,
    Map generatorTables,
    Map tableUniqueConstraints,
    Map mappedByResolver,
    Map propertyRefResolver,
    ReflectionManager reflectionManager) 
{
	
		super(
				classes,
				collections,
				tables,
				queries,
				sqlqueries,
				sqlResultSetMappings,
				imports,
				secondPasses,
				propertyReferences,
				namingStrategy,
				typeDefs,
				filterDefinitions,
				extendsQueue,
				auxiliaryDatabaseObjects,
				tableNameBinding,
				columnNameBindingPerTable
		);
		this.namedGenerators = namedGenerators;
		this.joins = joins;
		this.classTypes = classTypes;
		this.generatorTables = generatorTables;
		this.tableUniqueConstraints = tableUniqueConstraints;
		this.mappedByResolver = mappedByResolver;
		this.propertyRefResolver = propertyRefResolver;
		this.reflectionManager = reflectionManager;
		this.defaultNamedQueryNames = defaultNamedQueryNames;
		this.defaultNamedNativeQueryNames = defaultNamedNativeQueryNames;
		this.defaultSqlResulSetMappingNames = defaultSqlResulSetMappingNames;
		this.defaultNamedGenerators = defaultNamedGenerators;
}

 public AnnotatedClassType addClassType(XClass clazz) 
{
		AnnotatedClassType type;
		if ( clazz.isAnnotationPresent( Entity.class ) ) {
			type = AnnotatedClassType.ENTITY;
		}
		else if ( clazz.isAnnotationPresent( Embeddable.class ) ) {
			type = AnnotatedClassType.EMBEDDABLE;
		}
		else if ( clazz.isAnnotationPresent( MappedSuperclass.class ) ) {
			type = AnnotatedClassType.EMBEDDABLE_SUPERCLASS;
		}
		else {
			type = AnnotatedClassType.NONE;
		}
		classTypes.put( clazz.getName(), type );
		return type;
}

 public  void addDefaultGenerator(IdGenerator idGen) 
{
		this.addGenerator(idGen);
		defaultNamedGenerators.add( idGen.getName() );
}

 public  void addDefaultQuery(String name,
    NamedQueryDefinition query) 
{
		super.addQuery(name, query);
		defaultNamedQueryNames.add( name );
}

 public  void addDefaultResultSetMapping(ResultSetMappingDefinition definition) 
{
		final String name = definition.getName();
		if ( ! defaultSqlResulSetMappingNames.contains( name )
				&& super.getResultSetMapping( name ) != null ) {
			resultSetMappings.remove( name );
		}
		super.addResultSetMapping(definition);
		defaultSqlResulSetMappingNames.add( name );
}

 public  void addDefaultSQLQuery(String name,
    NamedSQLQueryDefinition query) 
{
		super.addSQLQuery(name, query);
		defaultNamedNativeQueryNames.add( name );
}

 public  void addGenerator(IdGenerator generator) throws MappingException 
{
		if ( ! defaultNamedGenerators.contains( generator.getName() ) ) {
			Object old = namedGenerators.put( generator.getName(), generator );
			if ( old != null ) log.warn( "duplicate generator name: " + generator.getName() );
		}
}

 public  void addGeneratorTable(String name,
    Properties params) 
{
		Object old = generatorTables.put( name, params );
		if ( old != null ) log.warn( "duplicate generator table: " + name );
}

 public  void addJoins(PersistentClass persistentClass,
    Map joins) throws MappingException 
{
		Object old = this.joins.put( persistentClass.getEntityName(), joins );
		if ( old != null ) log.warn( "duplicate joins for class: " + persistentClass.getEntityName() );
}

 public  void addMappedBy(String entityName,
    String propertyName,
    String inversePropertyName) 
{
		mappedByResolver.put( entityName + "." + propertyName, inversePropertyName );
}

 public  void addPropertyReference(String referencedClass,
    String propertyName) 
{
		super.addPropertyReference( referencedClass, propertyName );
}

 public  void addPropertyReferencedAssociation(String entityName,
    String propertyName,
    String propertyRef) 
{
		propertyRefResolver.put( entityName + "." + propertyName, propertyRef );
}

 public  void addQuery(String name,
    NamedQueryDefinition query) throws MappingException 
{
		if ( ! defaultNamedQueryNames.contains( name ) ) super.addQuery( name, query );
}

 public  void addResultSetMapping(ResultSetMappingDefinition definition) 
{
		if ( ! defaultSqlResulSetMappingNames.contains( definition.getName() ) )
			super.addResultSetMapping( definition );
}

 public  void addSQLQuery(String name,
    NamedSQLQueryDefinition query) throws MappingException 
{
		if ( ! defaultNamedNativeQueryNames.contains( name ) ) super.addSQLQuery( name, query );
}

 public  void addUniqueConstraints(Table table,
    List uniqueConstraints) 
{
		List oldConstraints = tableUniqueConstraints.get( table );
		if ( oldConstraints == null ) {
			oldConstraints = new ArrayList();
			tableUniqueConstraints.put( table, oldConstraints );
		}
		oldConstraints.addAll( uniqueConstraints );
}

 public  void addUniquePropertyReference(String referencedClass,
    String propertyName) 
{
		super.addUniquePropertyReference( referencedClass, propertyName );
}

 public AnnotatedClassType getClassType(XClass clazz) 
{
		AnnotatedClassType type = classTypes.get( clazz.getName() );
		if ( type == null ) {
			return addClassType( clazz );
		}
		else {
			return type;
		}
}

get and maintain a cache of class type. A class can be an entity, a embedded objet or nothing.

 public Map getClasses() 
{
		return classes;
}

 public String getFromMappedBy(String entityName,
    String propertyName) 
{
		return mappedByResolver.get( entityName + "." + propertyName );
}

 public IdGenerator getGenerator(String name) 
{
		return getGenerator( name, null );
}

 public IdGenerator getGenerator(String name,
    Map localGenerators) 
{
		if ( localGenerators != null ) {
			IdGenerator result = localGenerators.get( name );
			if ( result != null ) return result;
		}
		return namedGenerators.get( name );
}

Try to find the generator from the localGenerators and then from the global generator list

 public Properties getGeneratorTableProperties(String name,
    Map localGeneratorTables) 
{
		if ( localGeneratorTables != null ) {
			Properties result = localGeneratorTables.get( name );
			if ( result != null ) return result;
		}
		return generatorTables.get( name );
}

 public Map getJoins(String persistentClass) 
{
		return joins.get( persistentClass );
}

 public String getPropertyReferencedAssociation(String entityName,
    String propertyName) 
{
		return propertyRefResolver.get( entityName + "." + propertyName );
}

 public ReflectionManager getReflectionManager() 
{
		return reflectionManager;
}

 public Map getTableUniqueConstraints() 
{
		return tableUniqueConstraints;
}