org.hibernate.mapping.Subclass.java Source code

Introduction

Here is the source code for org.hibernate.mapping.Subclass.java

Source

/*
 * Hibernate, Relational Persistence for Idiomatic Java
 *
 * License: GNU Lesser General Public License (LGPL), version 2.1 or later.
 * See the lgpl.txt file in the root directory or <http://www.gnu.org/licenses/lgpl-2.1.html>.
 */
package org.hibernate.mapping;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Map;

import org.hibernate.AssertionFailure;
import org.hibernate.EntityMode;
import org.hibernate.boot.spi.MetadataBuildingContext;
import org.hibernate.engine.OptimisticLockStyle;
import org.hibernate.internal.util.collections.JoinedIterator;
import org.hibernate.internal.util.collections.SingletonIterator;

/**
 * A sublass in a table-per-class-hierarchy mapping
 * @author Gavin King
 */
public class Subclass extends PersistentClass {
    private PersistentClass superclass;
    private Class classPersisterClass;
    private final int subclassId;

    public Subclass(PersistentClass superclass, MetadataBuildingContext metadataBuildingContext) {
        super(metadataBuildingContext);
        this.superclass = superclass;
        this.subclassId = superclass.nextSubclassId();
    }

    int nextSubclassId() {
        return getSuperclass().nextSubclassId();
    }

    public int getSubclassId() {
        return subclassId;
    }

    @Override
    public String getNaturalIdCacheRegionName() {
        return getSuperclass().getNaturalIdCacheRegionName();
    }

    public String getCacheConcurrencyStrategy() {
        return getRootClass().getCacheConcurrencyStrategy();
    }

    public RootClass getRootClass() {
        return getSuperclass().getRootClass();
    }

    public PersistentClass getSuperclass() {
        return superclass;
    }

    public Property getIdentifierProperty() {
        return getSuperclass().getIdentifierProperty();
    }

    public Property getDeclaredIdentifierProperty() {
        return null;
    }

    public KeyValue getIdentifier() {
        return getSuperclass().getIdentifier();
    }

    public boolean hasIdentifierProperty() {
        return getSuperclass().hasIdentifierProperty();
    }

    public Value getDiscriminator() {
        return getSuperclass().getDiscriminator();
    }

    public boolean isMutable() {
        return getSuperclass().isMutable();
    }

    public boolean isInherited() {
        return true;
    }

    public boolean isPolymorphic() {
        return true;
    }

    public void addProperty(Property p) {
        super.addProperty(p);
        getSuperclass().addSubclassProperty(p);
    }

    public void addMappedsuperclassProperty(Property p) {
        super.addMappedsuperclassProperty(p);
        getSuperclass().addSubclassProperty(p);
    }

    public void addJoin(Join j) {
        super.addJoin(j);
        getSuperclass().addSubclassJoin(j);
    }

    public Iterator getPropertyClosureIterator() {
        return new JoinedIterator(getSuperclass().getPropertyClosureIterator(), getPropertyIterator());
    }

    public Iterator getTableClosureIterator() {
        return new JoinedIterator(getSuperclass().getTableClosureIterator(), new SingletonIterator(getTable()));
    }

    public Iterator getKeyClosureIterator() {
        return new JoinedIterator(getSuperclass().getKeyClosureIterator(), new SingletonIterator(getKey()));
    }

    protected void addSubclassProperty(Property p) {
        super.addSubclassProperty(p);
        getSuperclass().addSubclassProperty(p);
    }

    protected void addSubclassJoin(Join j) {
        super.addSubclassJoin(j);
        getSuperclass().addSubclassJoin(j);
    }

    protected void addSubclassTable(Table table) {
        super.addSubclassTable(table);
        getSuperclass().addSubclassTable(table);
    }

    public boolean isVersioned() {
        return getSuperclass().isVersioned();
    }

    public Property getVersion() {
        return getSuperclass().getVersion();
    }

    public Property getDeclaredVersion() {
        return null;
    }

    public boolean hasEmbeddedIdentifier() {
        return getSuperclass().hasEmbeddedIdentifier();
    }

    public Class getEntityPersisterClass() {
        if (classPersisterClass == null) {
            return getSuperclass().getEntityPersisterClass();
        } else {
            return classPersisterClass;
        }
    }

    public Table getRootTable() {
        return getSuperclass().getRootTable();
    }

    public KeyValue getKey() {
        return getSuperclass().getIdentifier();
    }

    public boolean isExplicitPolymorphism() {
        return getSuperclass().isExplicitPolymorphism();
    }

    public void setSuperclass(PersistentClass superclass) {
        this.superclass = superclass;
    }

    public String getWhere() {
        return getSuperclass().getWhere();
    }

    public boolean isJoinedSubclass() {
        return getTable() != getRootTable();
    }

    public void createForeignKey() {
        if (!isJoinedSubclass()) {
            throw new AssertionFailure("not a joined-subclass");
        }
        getKey().createForeignKeyOfEntity(getSuperclass().getEntityName());
    }

    public void setEntityPersisterClass(Class classPersisterClass) {
        this.classPersisterClass = classPersisterClass;
    }

    public int getJoinClosureSpan() {
        return getSuperclass().getJoinClosureSpan() + super.getJoinClosureSpan();
    }

    public int getPropertyClosureSpan() {
        return getSuperclass().getPropertyClosureSpan() + super.getPropertyClosureSpan();
    }

    public Iterator getJoinClosureIterator() {
        return new JoinedIterator(getSuperclass().getJoinClosureIterator(), super.getJoinClosureIterator());
    }

    public boolean isClassOrSuperclassJoin(Join join) {
        return super.isClassOrSuperclassJoin(join) || getSuperclass().isClassOrSuperclassJoin(join);
    }

    public boolean isClassOrSuperclassTable(Table table) {
        return super.isClassOrSuperclassTable(table) || getSuperclass().isClassOrSuperclassTable(table);
    }

    public Table getTable() {
        return getSuperclass().getTable();
    }

    public boolean isForceDiscriminator() {
        return getSuperclass().isForceDiscriminator();
    }

    public boolean isDiscriminatorInsertable() {
        return getSuperclass().isDiscriminatorInsertable();
    }

    public java.util.Set getSynchronizedTables() {
        HashSet result = new HashSet();
        result.addAll(synchronizedTables);
        result.addAll(getSuperclass().getSynchronizedTables());
        return result;
    }

    public Object accept(PersistentClassVisitor mv) {
        return mv.accept(this);
    }

    public java.util.List getFilters() {
        java.util.List filters = new ArrayList(super.getFilters());
        filters.addAll(getSuperclass().getFilters());
        return filters;
    }

    public boolean hasSubselectLoadableCollections() {
        return super.hasSubselectLoadableCollections() || getSuperclass().hasSubselectLoadableCollections();
    }

    public String getTuplizerImplClassName(EntityMode mode) {
        String impl = super.getTuplizerImplClassName(mode);
        if (impl == null) {
            impl = getSuperclass().getTuplizerImplClassName(mode);
        }
        return impl;
    }

    public Map getTuplizerMap() {
        Map specificTuplizerDefs = super.getTuplizerMap();
        Map superclassTuplizerDefs = getSuperclass().getTuplizerMap();
        if (specificTuplizerDefs == null && superclassTuplizerDefs == null) {
            return null;
        } else {
            Map combined = new HashMap();
            if (superclassTuplizerDefs != null) {
                combined.putAll(superclassTuplizerDefs);
            }
            if (specificTuplizerDefs != null) {
                combined.putAll(specificTuplizerDefs);
            }
            return java.util.Collections.unmodifiableMap(combined);
        }
    }

    public Component getIdentifierMapper() {
        return superclass.getIdentifierMapper();
    }

    @Override
    public OptimisticLockStyle getOptimisticLockStyle() {
        return superclass.getOptimisticLockStyle();
    }
}