ExtendedMappings(Map classes,
    Map collections,
    Map tables,
    Map queries,
    Map sqlqueries,
    Map sqlResultSetMappings,
    Set<String> defaultNamedQueryNames,
    Set<String> defaultNamedNativeQueryNames,
    Set<String> defaultSqlResulSetMappingNames,
    Set<String> defaultNamedGenerators,
    Map imports,
    List secondPasses,
    List propertyReferences,
    NamingStrategy namingStrategy,
    Map typeDefs,
    Map filterDefinitions,
    Map namedGenerators,
    Map<String, Join> joins,
    Map<String, AnnotatedClassType> classTypes,
    Map extendsQueue,
    Map<String, TableDescription> tableNameBinding,
    Map<Table, ColumnNames> columnNameBindingPerTable,
    List auxiliaryDatabaseObjects,
    Map<String, Properties> generatorTables,
    Map<String> tableUniqueConstraints,
    Map<String, String> mappedByResolver,
    Map<String, String> propertyRefResolver,
    Map<String, AnyMetaDef> anyMetaDefs,
    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;
		this.anyMetaDefs = anyMetaDefs;
}

 public  void addAnyMetaDef(AnyMetaDef defAnn) 
{
		if ( anyMetaDefs.containsKey( defAnn.name() ) ) {
			throw new AnnotationException( "Two @AnyMetaDef with the same name defined: " + defAnn.name() );
		}
		anyMetaDefs.put( defAnn.name(), defAnn );
}

 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<String, Join> 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 AnyMetaDef getAnyMetaDef(String name) 
{
		return anyMetaDefs.get( name );
}

 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<String, IdGenerator> 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<String, Properties> localGeneratorTables) 
{
		if ( localGeneratorTables != null ) {
			Properties result = localGeneratorTables.get( name );
			if ( result != null ) return result;
		}
		return generatorTables.get( name );
}

 public Map<String, Join> 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<String> getTableUniqueConstraints() 
{
		return tableUniqueConstraints;
}