public MappingRepository() 
{
                 
        setValidate(VALIDATE_MAPPING, true);
}

Default constructor. Configure via org.apache.openjpa.lib.conf.Configurable .

 public synchronized QueryResultMapping addQueryResultMapping(Class cls,
    String name) 
{
        QueryResultMapping res = new QueryResultMapping(name, this);
        res.setDefiningType(cls);
        _results.put(getQueryResultKey(res), res);
        return res;
}

Add a query result mapping.

 public synchronized  void clear() 
{
        super.clear();
        _schema = null;
        _results.clear();
}

 protected ValueHandler defaultHandler(ValueMapping val) 
{
        return defaultHandler(val, getStrategyInstaller().isAdapting());
}

Determine the default handler to use for the given value. Does not take into account the named handler, if any.

 protected ValueHandler defaultHandler(ValueMapping val,
    boolean adapting) 
{
        if (val.isSerialized()) {
            if (_dict.maxEmbeddedBlobSize != -1)
                warnMaxEmbedded(val, _dict.maxEmbeddedBlobSize);
            return BlobValueHandler.getInstance();
        }
        Object handler = mappedStrategy(val, val.getType(), adapting);
        if (handler instanceof ValueHandler)
            return (ValueHandler) handler;
        if (val.getType() == byte[].class 
            || val.getType() == Byte[].class) {
            if (_dict.maxEmbeddedBlobSize != -1)
                warnMaxEmbedded(val, _dict.maxEmbeddedBlobSize);
            return ByteArrayValueHandler.getInstance();
        }
        if (val.getType() == char[].class
            || val.getType() == Character[].class) {
            if (isClob(val, true))
                return CharArrayStreamValueHandler.getInstance();
            return CharArrayValueHandler.getInstance();
        }
        switch (val.getTypeCode()) {
            case JavaTypes.BOOLEAN:
            case JavaTypes.BYTE:
            case JavaTypes.CHAR:
            case JavaTypes.DOUBLE:
            case JavaTypes.FLOAT:
            case JavaTypes.INT:
            case JavaTypes.LONG:
            case JavaTypes.SHORT:
            case JavaTypes.BOOLEAN_OBJ:
            case JavaTypes.BYTE_OBJ:
            case JavaTypes.CHAR_OBJ:
            case JavaTypes.DOUBLE_OBJ:
            case JavaTypes.FLOAT_OBJ:
            case JavaTypes.INT_OBJ:
            case JavaTypes.LONG_OBJ:
            case JavaTypes.SHORT_OBJ:
            case JavaTypes.BIGINTEGER:
            case JavaTypes.BIGDECIMAL:
            case JavaTypes.NUMBER:
            case JavaTypes.DATE:
            case JavaTypes.CALENDAR:
            case JavaTypes.LOCALE:
                return ImmutableValueHandler.getInstance();
            case JavaTypes.STRING:
                if (isClob(val, true))
                    return ClobValueHandler.getInstance();
                return ImmutableValueHandler.getInstance();
            case JavaTypes.PC:
                if (!val.getTypeMapping().isMapped()
                    && useUntypedPCHandler(val)) 
                    return UntypedPCValueHandler.getInstance();
                break;
            case JavaTypes.PC_UNTYPED:
                return UntypedPCValueHandler.getInstance();
            case JavaTypes.OID:
                return new ObjectIdValueHandler();
        }
        if (!getConfiguration().getCompatibilityInstance()
            .getStoreMapCollectionInEntityAsBlob()
            && val.isEmbeddedPC())
            return new ElementEmbedValueHandler();
        return null;
}

Determine the default handler to use for the given value. Does not take into account the named handler, if any.

 protected ClassStrategy defaultStrategy(ClassMapping cls) 
{
        return defaultStrategy(cls, getStrategyInstaller().isAdapting());
}

Determine the default strategy to use for the given class. Does not take into account the current strategy, if any.

 protected DiscriminatorStrategy defaultStrategy(Discriminator discrim) 
{
        return defaultStrategy(discrim, getStrategyInstaller().isAdapting());
}

Determine the default strategy to use for the given discriminator. Does not take into account the current strategy, if any.

 protected VersionStrategy defaultStrategy(Version version) 
{
        return defaultStrategy(version, getStrategyInstaller().isAdapting());
}

Determine the default strategy to use for the given version. Does not take into account the current strategy, if any.

 protected ClassStrategy defaultStrategy(ClassMapping cls,
    boolean adapting) 
{
        ValueMapping embed = cls.getEmbeddingMapping();
        if (embed != null) {
            // superclass of embedded class isn't mapped
            if (embed.getType() != cls.getDescribedType()
                || embed.getFieldMapping().getStrategy()
                == NoneFieldStrategy.getInstance())
                return NoneClassStrategy.getInstance();
            if (embed.getTypeCode() == JavaTypes.OID)
                return new ObjectIdClassStrategy();
            return new EmbeddedClassStrategy();
        }
        if (cls.isEmbeddedOnly())
            return NoneClassStrategy.getInstance();
        Object strat = _defaults.getStrategy(cls, adapting);
        if (strat instanceof String)
            return instantiateClassStrategy((String) strat, cls);
        if (strat != null)
            return (ClassStrategy) strat;
        // see if there is a declared hierarchy strategy
        ClassStrategy hstrat = null;
        for (ClassMapping base = cls; base != null && hstrat == null;) {
            hstrat = instantiateClassStrategy(base.getMappingInfo().
                getHierarchyStrategy(), cls);
            base = base.getMappedPCSuperclassMapping();
        }
        // the full strategy as applied to a hierarchy is a
        // table-per-concrete-class strategy, so don't map abstract types
        if (hstrat instanceof FullClassStrategy
            && !cls.isManagedInterface()
            && Modifier.isAbstract(cls.getDescribedType().getModifiers()))
            return NoneClassStrategy.getInstance();
        ClassMapping sup = cls.getMappedPCSuperclassMapping();
        if (sup == null)
            return new FullClassStrategy();
        if (hstrat != null)
            return hstrat;
        return new FlatClassStrategy();
}

Determine the default strategy to use for the given class. Does not take into account the current strategy, if any.

 protected FieldStrategy defaultStrategy(FieldMapping field,
    boolean installHandlers) 
{
        return defaultStrategy(field, installHandlers,
            getStrategyInstaller().isAdapting());
}

Determine the default strategy to use for the given field. Does not take into account the named or current strategy, if any. If a non-null strategy is returned, this method may as a side effect install value handlers on the field's value mappings.

 protected DiscriminatorStrategy defaultStrategy(Discriminator discrim,
    boolean adapting) 
{
        ClassMapping cls = discrim.getClassMapping();
        if (cls.getEmbeddingMetaData() != null)
            return NoneDiscriminatorStrategy.getInstance();
        if (cls.getJoinablePCSuperclassMapping() == null
            && (cls.getStrategy() == NoneClassStrategy.getInstance()
            || Modifier.isFinal(discrim.getClassMapping().getDescribedType().
            getModifiers())))
            return NoneDiscriminatorStrategy.getInstance();
        Object strat = _defaults.getStrategy(discrim, adapting);
        if (strat instanceof String)
            return instantiateDiscriminatorStrategy((String) strat, discrim);
        if (strat != null)
            return (DiscriminatorStrategy) strat;
        if (cls.getJoinablePCSuperclassMapping() != null)
            return new SuperclassDiscriminatorStrategy();
        if (discrim.getMappingInfo().getValue() != null)
            return new ValueMapDiscriminatorStrategy();
        if (cls.getMappedPCSuperclassMapping() != null)
            return NoneDiscriminatorStrategy.getInstance();
        if (adapting || _defaults.defaultMissingInfo())
            return new ClassNameDiscriminatorStrategy();
        DBDictionary dict = ((JDBCConfiguration) getConfiguration()).
            getDBDictionaryInstance();
        if (dict.joinSyntax == JoinSyntaxes.SYNTAX_TRADITIONAL)
            return NoneDiscriminatorStrategy.getInstance();
        return new SubclassJoinDiscriminatorStrategy();
}

Determine the default strategy to use for the given discriminator. Does not take into account the current strategy, if any.

 protected VersionStrategy defaultStrategy(Version version,
    boolean adapting) 
{
        ClassMapping cls = version.getClassMapping();
        if (cls.getEmbeddingMetaData() != null)
            return NoneVersionStrategy.getInstance();
        if (cls.getJoinablePCSuperclassMapping() == null
            && cls.getStrategy() == NoneClassStrategy.getInstance())
            return NoneVersionStrategy.getInstance();
        Object strat = _defaults.getStrategy(version, adapting);
        if (strat instanceof String)
            return instantiateVersionStrategy((String) strat, version);
        if (strat != null)
            return (VersionStrategy) strat;
        if (cls.getJoinablePCSuperclassMapping() != null)
            return new SuperclassVersionStrategy();
        FieldMapping vfield = version.getClassMapping().
            getVersionFieldMapping();
        if (vfield != null)
            return defaultStrategy(version, vfield);
        if (adapting || _defaults.defaultMissingInfo())
            return new NumberVersionStrategy();
        return NoneVersionStrategy.getInstance();
}

Determine the default strategy to use for the given version. Does not take into account the current strategy, if any.

 protected VersionStrategy defaultStrategy(Version vers,
    FieldMapping vfield) 
{
        switch (vfield.getTypeCode()) {
            case JavaTypes.DATE:
            case JavaTypes.CALENDAR:
                return (JavaVersions.VERSION  >= 5) 
                    ? new NanoPrecisionTimestampVersionStrategy()
                    : new TimestampVersionStrategy();
            case JavaTypes.BYTE:
            case JavaTypes.INT:
            case JavaTypes.LONG:
            case JavaTypes.SHORT:
            case JavaTypes.BYTE_OBJ:
            case JavaTypes.INT_OBJ:
            case JavaTypes.LONG_OBJ:
            case JavaTypes.SHORT_OBJ:
            case JavaTypes.NUMBER:
                return new NumberVersionStrategy();
            default:
                return NoneVersionStrategy.getInstance();
        }
}

Return the default version strategy, given a version field.

 protected FieldStrategy defaultStrategy(FieldMapping field,
    boolean installHandlers,
    boolean adapting) 
{
        // not persistent?
        if (field.getManagement() != field.MANAGE_PERSISTENT
            || field.isVersion())
            return NoneFieldStrategy.getInstance();
        if (field.getDefiningMapping().getStrategy() ==
            NoneClassStrategy.getInstance())
            return NoneFieldStrategy.getInstance();
        // check for named handler first
        ValueHandler handler = namedHandler(field);
        if (handler != null) {
            if (installHandlers)
                field.setHandler(handler);
            return new HandlerFieldStrategy();
        }
        if (field.isSerialized()) {
            if (_dict.maxEmbeddedBlobSize != -1)
                return new MaxEmbeddedBlobFieldStrategy();
        } else {
            // check for mapped strategy
            Object strat = mappedStrategy(field, field.getType(), adapting);
            if (strat instanceof FieldStrategy)
                return (FieldStrategy) strat;
            if (strat != null) {
                if (installHandlers)
                    field.setHandler((ValueHandler) strat);
                return new HandlerFieldStrategy();
            }
        }
        // check for known field strategies
        if (!field.isSerialized() && (field.getType() == byte[].class
            || field.getType() == Byte[].class)) {
            if (_dict.maxEmbeddedBlobSize != -1)
                return new MaxEmbeddedByteArrayFieldStrategy();
        } else if (!field.isSerialized()
            && (field.getType() == char[].class
            || field.getType() == Character[].class)) {
            if (_dict.maxEmbeddedClobSize != -1 && isClob(field, false))
                return new MaxEmbeddedCharArrayFieldStrategy();
        } else if (!field.isSerialized()) {
            FieldStrategy strat = defaultTypeStrategy(field, installHandlers,
                adapting);
            if (strat != null)
                return strat;
        }
        // check for default handler
        handler = defaultHandler(field, adapting);
        if (handler != null) {
            if (installHandlers)
                field.setHandler(handler);
            return new HandlerFieldStrategy();
        }
        // default to blob
        if (installHandlers) {
            if (getLog().isWarnEnabled())
                getLog().warn(_loc.get("no-field-strategy", field));
            field.setSerialized(true);
        }
        if (_dict.maxEmbeddedBlobSize == -1) {
            if (installHandlers)
                field.setHandler(BlobValueHandler.getInstance());
            return new HandlerFieldStrategy();
        }
        return new MaxEmbeddedBlobFieldStrategy();
}

Determine the default strategy to use for the given field. Does not take into account the named or current strategy, if any. If a non-null strategy is returned, this method may as a side effect install value handlers on the field's value mappings.

 protected FieldStrategy defaultTypeStrategy(FieldMapping field,
    boolean installHandlers,
    boolean adapting) 
{
        switch (field.getTypeCode()) {
            case JavaTypes.BOOLEAN:
            case JavaTypes.BYTE:
            case JavaTypes.CHAR:
            case JavaTypes.DOUBLE:
            case JavaTypes.FLOAT:
            case JavaTypes.INT:
            case JavaTypes.LONG:
            case JavaTypes.SHORT:
                return new PrimitiveFieldStrategy();
            case JavaTypes.STRING:
                if (!isClob(field, false))
                    return new StringFieldStrategy();
                if (_dict.maxEmbeddedClobSize != -1)
                    return new MaxEmbeddedClobFieldStrategy();
                break;
            case JavaTypes.PC:
                if (field.isEmbeddedPC())
                    return new EmbedFieldStrategy();
                if (field.getTypeMapping().isMapped()
                    || !useUntypedPCHandler(field))
                    return new RelationFieldStrategy();
                break;
            case JavaTypes.ARRAY:
            case JavaTypes.COLLECTION:
                ValueMapping elem = field.getElementMapping();
                ValueHandler ehandler = namedHandler(elem);
                if (ehandler == null)
                    ehandler = defaultHandler(elem);
                if (ehandler != null)
                    return handlerCollectionStrategy(field, ehandler, 
                        installHandlers);
                if (elem.getTypeCode() == JavaTypes.PC
                    && !elem.isSerialized() && !elem.isEmbeddedPC()) {
                    if (useInverseKeyMapping(field))
                        return new RelationCollectionInverseKeyFieldStrategy();
                    return new RelationCollectionTableFieldStrategy();
                }
                break;
            case JavaTypes.MAP:
                ValueMapping key = field.getKeyMapping();
                ValueHandler khandler = namedHandler(key);
                if (khandler == null)
                    khandler = defaultHandler(key);
                ValueMapping val = field.getElementMapping();
                ValueHandler vhandler = namedHandler(val);
                if (vhandler == null)
                    vhandler = defaultHandler(val);
                boolean krel = khandler == null 
                    && key.getTypeCode() == JavaTypes.PC
                    && !key.isSerialized() && !key.isEmbeddedPC();
                boolean vrel = vhandler == null 
                    && val.getTypeCode() == JavaTypes.PC
                    && !val.isSerialized() && !val.isEmbeddedPC();
                if (!krel && vrel && key.getValueMappedBy() != null) {
                    if (useInverseKeyMapping(field))
                        return new RelationMapInverseKeyFieldStrategy();
                    return new RelationMapTableFieldStrategy();
                }
                if (!krel && khandler == null)
                    break;
                if (!vrel && vhandler == null)
                    break;
                return handlerMapStrategy(field, khandler, vhandler, krel,
                    vrel, installHandlers);
            case JavaTypes.INPUT_STREAM:
            case JavaTypes.INPUT_READER:
                return new LobFieldStrategy();
        }
        return null;
}

Return the built-in strategy for the field's type, or null if none.

 public  void endConfiguration() 
{
        super.endConfiguration();
        JDBCConfiguration conf = (JDBCConfiguration) getConfiguration();
        _dict = conf.getDBDictionaryInstance();
        if (_defaults == null)
            _defaults = conf.getMappingDefaultsInstance();
        if (_schema != null && _schema instanceof Configurable) {
            ((Configurable) _schema).setConfiguration(conf);
            ((Configurable) _schema).startConfiguration();
            ((Configurable) _schema).endConfiguration();
        }
}

 public synchronized QueryResultMapping getCachedQueryResultMapping(Class cls,
    String name) 
{
        return (QueryResultMapping) _results.get(getQueryResultKey(cls, name));
}

Return the cached query result mapping with the given name, or null if none.

 public DBDictionary getDBDictionary() 
{
        return _dict;
}

Convenient access to dictionary for mappings.

 public ClassMapping[] getImplementorMappings(Class cls,
    ClassLoader envLoader,
    boolean mustExist) 
{
        return (ClassMapping[]) super.getImplementorMetaDatas(cls, envLoader,
            mustExist);
}

 public ClassMapping getMapping(Class cls,
    ClassLoader envLoader,
    boolean mustExist) 
{
        return (ClassMapping) super.getMetaData(cls, envLoader, mustExist);
}

 public ClassMapping getMapping(Object oid,
    ClassLoader envLoader,
    boolean mustExist) 
{
        return (ClassMapping) super.getMetaData(oid, envLoader, mustExist);
}

 public MappingDefaults getMappingDefaults() 
{
        return _defaults;
}

Mapping defaults.

 public ClassMapping[] getMappings() 
{
        return (ClassMapping[]) super.getMetaDatas();
}

 public synchronized QueryResultMapping getQueryResultMapping(Class cls,
    String name,
    ClassLoader envLoader,
    boolean mustExist) 
{
        QueryResultMapping res = getQueryResultMappingInternal(cls, name,
            envLoader);
        if (res == null && mustExist)
            throw new MetaDataException(_loc.get("no-query-res", cls, name));
        return res;
}

Return the query result mapping for the given name.

 public synchronized QueryResultMapping[] getQueryResultMappings() 
{
        Collection values = _results.values();
        return (QueryResultMapping[]) values.toArray
            (new QueryResultMapping[values.size()]);
}

Return all cached query result mappings.

 public synchronized SchemaGroup getSchemaGroup() 
{
        if (_schema == null)
            _schema = ((JDBCConfiguration) getConfiguration()).
                getSchemaFactoryInstance().readSchema();
        return _schema;
}

Representation of the database schema.

 public synchronized StrategyInstaller getStrategyInstaller() 
{
        if (_installer == null)
            _installer = new RuntimeStrategyInstaller(this);
        return _installer;
}

Installs mapping strategies on components.

 protected FieldStrategy handlerCollectionStrategy(FieldMapping field,
    ValueHandler ehandler,
    boolean installHandlers) 
{
        if (getConfiguration().getCompatibilityInstance()
            .getStoreMapCollectionInEntityAsBlob())
            return null;
        if (installHandlers)
            field.getElementMapping().setHandler(ehandler);
        return new HandlerCollectionTableFieldStrategy();
}

Return the collection strategy for the given element handler, or null if none.

 protected FieldStrategy handlerMapStrategy(FieldMapping field,
    ValueHandler khandler,
    ValueHandler vhandler,
    boolean krel,
    boolean vrel,
    boolean installHandlers) 
{
        if (getConfiguration().getCompatibilityInstance()
            .getStoreMapCollectionInEntityAsBlob())
            return null;
        if (installHandlers) {
            field.getKeyMapping().setHandler(khandler);
            field.getElementMapping().setHandler(vhandler);
        }
        if (!krel && !vrel)
            return new HandlerHandlerMapTableFieldStrategy();
        if (!krel && vrel)
            return new HandlerRelationMapTableFieldStrategy();
        if (krel && !vrel)
            return new RelationHandlerMapTableFieldStrategy();
        return new RelationRelationMapTableFieldStrategy();
}

Return the map strategy for the given key and value handlers / relations, or null if none.

 protected ClassStrategy instantiateClassStrategy(String name,
    ClassMapping cls) 
{
        if (name == null)
            return null;
        if (NoneClassStrategy.ALIAS.equals(name))
            return NoneClassStrategy.getInstance();
        String props = Configurations.getProperties(name);
        name = Configurations.getClassName(name);
        Class strat = null;
        // base and vertical strategies use same alias; differentiate on join
        if (FullClassStrategy.ALIAS.equals(name))
            strat = FullClassStrategy.class;
        else if (FlatClassStrategy.ALIAS.equals(name))
            strat = FlatClassStrategy.class;
        else if (VerticalClassStrategy.ALIAS.equals(name))
            strat = VerticalClassStrategy.class;
        try {
            if (strat == null)
                strat = JavaTypes.classForName(name, cls,
                    (ClassLoader) AccessController.doPrivileged(
                        J2DoPrivHelper.getClassLoaderAction(
                            ClassStrategy.class)));
            ClassStrategy strategy = 
                (ClassStrategy) AccessController.doPrivileged(
                    J2DoPrivHelper.newInstanceAction(strat));
            Configurations.configureInstance(strategy, getConfiguration(),
                props);
            return strategy;
        } catch (Exception e) {
            if (e instanceof PrivilegedActionException)
                e = ((PrivilegedActionException) e).getException();
            throw new MetaDataException(_loc.get("bad-cls-strategy",
                cls, name), e);
        }
}

Return the strategy for the given name.

 protected DiscriminatorStrategy instantiateDiscriminatorStrategy(String name,
    Discriminator discrim) 
{
        if (NoneDiscriminatorStrategy.ALIAS.equals(name))
            return NoneDiscriminatorStrategy.getInstance();
        String props = Configurations.getProperties(name);
        name = Configurations.getClassName(name);
        Class strat = null;
        if (ClassNameDiscriminatorStrategy.ALIAS.equals(name))
            strat = ClassNameDiscriminatorStrategy.class;
        else if (ValueMapDiscriminatorStrategy.ALIAS.equals(name))
            strat = ValueMapDiscriminatorStrategy.class;
        else if (SubclassJoinDiscriminatorStrategy.ALIAS.equals(name))
            strat = SubclassJoinDiscriminatorStrategy.class;
        try {
            if (strat == null)
                strat = JavaTypes.classForName(name,
                    discrim.getClassMapping(),
                    (ClassLoader) AccessController.doPrivileged(
                        J2DoPrivHelper.getClassLoaderAction(
                            DiscriminatorStrategy.class)));
            DiscriminatorStrategy strategy = (DiscriminatorStrategy)
                AccessController.doPrivileged(
                    J2DoPrivHelper.newInstanceAction(strat));
            Configurations.configureInstance(strategy, getConfiguration(),
                props);
            return strategy;
        } catch (Exception e) {
            if (e instanceof PrivilegedActionException)
                e = ((PrivilegedActionException) e).getException();
            throw new MetaDataException(_loc.get("bad-discrim-strategy",
                discrim.getClassMapping(), name), e);
        }
}

Instantiate the given discriminator strategy.

 protected VersionStrategy instantiateVersionStrategy(String name,
    Version version) 
{
        if (NoneVersionStrategy.ALIAS.equals(name))
            return NoneVersionStrategy.getInstance();
        String props = Configurations.getProperties(name);
        name = Configurations.getClassName(name);
        Class strat = null;
        if (NumberVersionStrategy.ALIAS.equals(name))
            strat = NumberVersionStrategy.class;
        else if (TimestampVersionStrategy.ALIAS.equals(name))
            strat = TimestampVersionStrategy.class;
        else if (NanoPrecisionTimestampVersionStrategy.ALIAS.equals(name))
            strat = NanoPrecisionTimestampVersionStrategy.class;
        else if (StateComparisonVersionStrategy.ALIAS.equals(name))
            strat = StateComparisonVersionStrategy.class;
        try {
            if (strat == null)
                strat = JavaTypes.classForName(name,
                    version.getClassMapping(),
                    (ClassLoader) AccessController.doPrivileged(
                        J2DoPrivHelper.getClassLoaderAction(
                            VersionStrategy.class)));
        } catch (Exception e) {
            throw new MetaDataException(_loc.get("bad-version-strategy",
                version.getClassMapping(), name), e);
        }
        return instantiateVersionStrategy(strat, version, props);
}

Instantiate the given version strategy.

 protected VersionStrategy instantiateVersionStrategy(Class strat,
    Version version,
    String props) 
{
        try {
            VersionStrategy strategy = (VersionStrategy)
                AccessController.doPrivileged(
                    J2DoPrivHelper.newInstanceAction(strat));
            Configurations.configureInstance(strategy, getConfiguration(),
                props);
            return strategy;
        } catch (Exception e) {
            if (e instanceof PrivilegedActionException)
                e = ((PrivilegedActionException) e).getException();
            throw new MetaDataException(_loc.get("bad-version-strategy",
                version.getClassMapping(), strat + ""), e);
        }
}

Instantiate the given version strategy.

 protected ValueHandler namedHandler(ValueMapping val) 
{
        String name = val.getValueInfo().getStrategy();
        if (name == null)
            return null;
        String props = Configurations.getProperties(name);
        name = Configurations.getClassName(name);
        try {
            Class c = JavaTypes.classForName(name, val,
                (ClassLoader) AccessController.doPrivileged(
                    J2DoPrivHelper.getClassLoaderAction(ValueHandler.class)));
            if (ValueHandler.class.isAssignableFrom(c)) {
                ValueHandler vh = (ValueHandler) AccessController.doPrivileged(
                    J2DoPrivHelper.newInstanceAction(c));
                Configurations.configureInstance(vh, getConfiguration(),
                    props);
                return vh;
            }
            return null; // named field strategy
        } catch (Exception e) {
            if (e instanceof PrivilegedActionException)
                e = ((PrivilegedActionException) e).getException();
            throw new MetaDataException(_loc.get("bad-value-handler",
                val, name), e);
        }
}

Instantiate the given value's named handler, or return null if no named handler.

 protected ClassStrategy namedStrategy(ClassMapping cls) 
{
        String name = cls.getMappingInfo().getStrategy();
        return instantiateClassStrategy(name, cls);
}

Instantiate the given class' named strategy, or return null if no named strategy.

 protected DiscriminatorStrategy namedStrategy(Discriminator discrim) 
{
        String name = discrim.getMappingInfo().getStrategy();
        if (name == null)
            return null;
        // if there is a named strategy present, discard it if it matches
        // the base strategy, so that we won't create an independent instance
        ClassMapping cls = discrim.getClassMapping();
        while (cls.getJoinablePCSuperclassMapping() != null)
            cls = cls.getJoinablePCSuperclassMapping();
        Discriminator base = cls.getDiscriminator();
        if (base != discrim && base.getStrategy() != null
            && name.equals(base.getStrategy().getAlias()))
            return null;
        return instantiateDiscriminatorStrategy(name, discrim);
}

Instantiate the given discriminator's named strategy, or return null if no named strategy.

 protected VersionStrategy namedStrategy(Version version) 
{
        String name = version.getMappingInfo().getStrategy();
        if (name == null)
            return null;
        // if there is a named strategy present, discard it if it matches
        // the base strategy, so that we won't create an independent instance
        ClassMapping cls = version.getClassMapping();
        while (cls.getJoinablePCSuperclassMapping() != null)
            cls = cls.getJoinablePCSuperclassMapping();
        Version base = cls.getVersion();
        if (base != version && base.getStrategy() != null
            && name.equals(base.getStrategy().getAlias()))
            return null;
        return instantiateVersionStrategy(name, version);
}

Instantiate the given version's named strategy, or return null if no named strategy.

 protected FieldStrategy namedStrategy(FieldMapping field,
    boolean installHandlers) 
{
        String name = field.getMappingInfo().getStrategy();
        if (name == null)
            return null;
        if (NoneFieldStrategy.ALIAS.equals(name))
            return NoneFieldStrategy.getInstance();
        String props = Configurations.getProperties(name);
        name = Configurations.getClassName(name);
        try {
            Class c = JavaTypes.classForName(name, field,
                (ClassLoader) AccessController.doPrivileged(
                    J2DoPrivHelper.getClassLoaderAction(FieldStrategy.class)));
            if (FieldStrategy.class.isAssignableFrom(c)) {
                FieldStrategy strat = (FieldStrategy)
                    AccessController.doPrivileged(
                        J2DoPrivHelper.newInstanceAction(c));
                Configurations.configureInstance(strat, getConfiguration(),
                    props);
                return strat;
            }
            // must be named handler
            if (installHandlers) {
                ValueHandler vh = (ValueHandler) AccessController.doPrivileged(
                    J2DoPrivHelper.newInstanceAction(c));
                Configurations.configureInstance(vh, getConfiguration(),
                    props);
                field.setHandler(vh);
            }
            return new HandlerFieldStrategy();
        } catch (Exception e) {
            if (e instanceof PrivilegedActionException)
                e = ((PrivilegedActionException) e).getException();
            throw new MetaDataException(_loc.get("bad-field-strategy",
                field, name), e);
        }
}

Instantiate the given field's named strategy, or return null if no named strategy.

 protected ClassMetaData newClassMetaData(Class type) 
{
        return new ClassMapping(type, this);
}

 protected ClassMetaData[] newClassMetaDataArray(int length) 
{
        return new ClassMapping[length];
}

 protected Discriminator newDiscriminator(ClassMapping cls) 
{
        return new Discriminator(cls);
}

Create discriminator metadata for the given class.

 protected ClassMetaData newEmbeddedClassMetaData(ValueMetaData owner) 
{
        return new ClassMapping(owner);
}

 protected FieldMetaData newFieldMetaData(String name,
    Class type,
    ClassMetaData owner) 
{
        return new FieldMapping(name, type, (ClassMapping) owner);
}

 protected FieldMetaData[] newFieldMetaDataArray(int length) 
{
        return new FieldMapping[length];
}

 protected ClassMappingInfo newMappingInfo(ClassMapping cls) 
{
        ClassMappingInfo info = new ClassMappingInfo();
        info.setClassName(cls.getDescribedType().getName());
        return info;
}

Create raw mapping info for the given instance.

 protected FieldMappingInfo newMappingInfo(FieldMapping fm) 
{
        return new FieldMappingInfo();
}

Create raw mapping info for the given instance.

 protected ValueMappingInfo newMappingInfo(ValueMapping vm) 
{
        return new ValueMappingInfo();
}

Create raw mapping info for the given instance.

 protected VersionMappingInfo newMappingInfo(Version version) 
{
        return new VersionMappingInfo();
}

Create raw mapping info for the given instance.

 protected DiscriminatorMappingInfo newMappingInfo(Discriminator disc) 
{
        return new DiscriminatorMappingInfo();
}

Create raw mapping info for the given instance.

 protected Order[] newOrderArray(int size) 
{
        return new JDBCOrder[size];
}

 protected Order newRelatedFieldOrder(FieldMetaData owner,
    FieldMetaData rel,
    boolean asc) 
{
        return new JDBCRelatedFieldOrder((FieldMapping) owner,
            (FieldMapping) rel, asc);
}

 protected SequenceMetaData newSequenceMetaData(String name) 
{
        return new SequenceMapping(name, this);
}

 protected ValueMetaData newValueMetaData(FieldMetaData owner) 
{
        return new ValueMappingImpl((FieldMapping) owner);
}

 protected Order newValueOrder(FieldMetaData owner,
    boolean asc) 
{
        return new JDBCValueOrder((FieldMapping) owner, asc);
}

 protected Version newVersion(ClassMapping cls) 
{
        return new Version(cls);
}

Create version metadata for the given class.

 protected  void prepareMapping(ClassMetaData meta) 
{
        // make sure superclass resolved first; resolving superclass may have
        // resolved this mapping
        ClassMapping mapping = (ClassMapping) meta;
        ClassMapping sup = mapping.getPCSuperclassMapping();
        if (sup != null && (mapping.getResolve() & MODE_MAPPING) != 0)
            return;
        // define superclass fields after mapping class, so we can tell whether
        // the class is mapped and needs to redefine abstract superclass fields
        getStrategyInstaller().installStrategy(mapping);
        mapping.defineSuperclassFields(mapping.getJoinablePCSuperclassMapping()
            == null);
        // resolve everything that doesn't involve relations to allow relation
        // mappings to use the others as joinables
        mapping.resolveNonRelationMappings();
}

 public synchronized boolean removeQueryResultMapping(QueryResultMapping res) 
{
        return _results.remove(getQueryResultKey(res)) != null;
}

Remove a query result mapping.

 public synchronized boolean removeQueryResultMapping(Class cls,
    String name) 
{
        if (name == null)
            return false;
        return _results.remove(getQueryResultKey(cls, name)) != null;
}

Remove a query result mapping.

 public  void setMappingDefaults(MappingDefaults defaults) 
{
        _defaults = defaults;
}

Mapping default.

 public synchronized  void setSchemaGroup(SchemaGroup schema) 
{
        _schema = schema;
}

Representation of the database schema.

 public synchronized  void setStrategyInstaller(StrategyInstaller installer) 
{
        _installer = installer;
}

Installs mapping strategies on components.