public  void clear() 
{
        super.clear();
        if (_annoParser != null)
            _annoParser.clear();
        if (_xmlParser != null)
            _xmlParser.clear();
        if (_xml != null)
            _xml.clear();
}

 protected File defaultSourceFile(ClassMetaData meta) 
{
        return defaultXMLFile();
}

 protected File defaultSourceFile(QueryMetaData query,
    Map clsNames) 
{
        ClassMetaData meta = getDefiningMetaData(query, clsNames);
        File file = (meta == null) ? null : meta.getSourceFile();
        if (file != null)
            return file;
        return defaultXMLFile();
}

 protected File defaultSourceFile(SequenceMetaData seq,
    Map clsNames) 
{
        return defaultXMLFile();
}

 public  void endConfiguration() 
{
        if (rsrcs == null)
            rsrcs = Collections.singleton("META-INF/orm.xml");
        else
			rsrcs.add("META-INF/orm.xml");
}

 public AnnotationPersistenceMetaDataParser getAnnotationParser() 
{
        if (_annoParser == null) {
            _annoParser = newAnnotationParser();
            _annoParser.setRepository(repos);
        }
        return _annoParser;
}

Return metadata parser, creating it if it does not already exist.

 public MetaDataDefaults getDefaults() 
{
        return _def;
}

 public boolean getFieldOverride() 
{
        return _fieldOverride;
}

Whether to use field-level override or class-level override. Defaults to true.

 public Class getQueryScope(String queryName,
    ClassLoader loader) 
{
        if (queryName == null)
            return null;
        Collection classes = repos.loadPersistentTypes(false, loader);
        for (Class cls : (Collection< Class >) classes) {
            if (((Boolean) AccessController.doPrivileged(J2DoPriv5Helper
                .isAnnotationPresentAction(cls, NamedQuery.class)))
                .booleanValue() && hasNamedQuery
                (queryName, (NamedQuery) cls.getAnnotation(NamedQuery.class)))
                return cls;
            if (((Boolean) AccessController.doPrivileged(J2DoPriv5Helper
                .isAnnotationPresentAction(cls, NamedQueries.class)))
                .booleanValue() &&
                hasNamedQuery(queryName, ((NamedQueries) cls.
                    getAnnotation(NamedQueries.class)).value()))
                return cls;
            if (((Boolean) AccessController.doPrivileged(J2DoPriv5Helper
                .isAnnotationPresentAction(cls, NamedNativeQuery.class)))
                .booleanValue() &&
                hasNamedNativeQuery(queryName, (NamedNativeQuery) cls.
                    getAnnotation(NamedNativeQuery.class)))
                return cls;
            if (((Boolean) AccessController.doPrivileged(J2DoPriv5Helper
                .isAnnotationPresentAction(cls, NamedNativeQueries.class)))
                .booleanValue() &&
                hasNamedNativeQuery(queryName, ((NamedNativeQueries) cls.
                    getAnnotation(NamedNativeQueries.class)).value()))
                return cls;
        }
        return null;
}

 public Class getResultSetMappingScope(String rsMappingName,
    ClassLoader loader) 
{
        if (rsMappingName == null)
            return null;
        Collection classes = repos.loadPersistentTypes(false, loader);
        for (Class cls : (Collection< Class >) classes) {
            if (((Boolean) AccessController.doPrivileged(J2DoPriv5Helper
                .isAnnotationPresentAction(cls, SqlResultSetMapping.class)))
                .booleanValue() &&
                hasRSMapping(rsMappingName, (SqlResultSetMapping) cls.
                getAnnotation(SqlResultSetMapping.class)))
                return cls;
            if (((Boolean) AccessController.doPrivileged(J2DoPriv5Helper
                .isAnnotationPresentAction(cls, SqlResultSetMappings.class)))
                .booleanValue() &&
                hasRSMapping(rsMappingName, ((SqlResultSetMappings) cls.
                getAnnotation(SqlResultSetMappings.class)).value()))
                return cls;
        }
        return null;
}

 public AnnotationPersistenceXMLMetaDataParser getXMLAnnotationParser() 
{
        if (_annoXMLParser == null) {
            _annoXMLParser = newXMLAnnotationParser();
            _annoXMLParser.setRepository(repos);
        }
        return _annoXMLParser;
}

Return JAXB XML annotation parser, creating it if it does not already exist.

 public XMLPersistenceMetaDataParser getXMLParser() 
{
        if (_xmlParser == null) {
            _xmlParser = newXMLParser(true);
            _xmlParser.setRepository(repos);
            if (_fieldOverride)
                _xmlParser.setAnnotationParser(getAnnotationParser());
        }
        return _xmlParser;
}

Return XML metadata parser, creating it if it does not already exist.

 public  void load(Class cls,
    int mode,
    ClassLoader envLoader) 
{
        if (mode == MODE_NONE)
            return;
        if (!strict && (mode & MODE_META) != 0)
            mode |= MODE_MAPPING;
        // getting the list of persistent types runs callbacks to
        // mapPersistentTypeNames if it hasn't been called already, which
        // caches XML resources
        getPersistentTypeNames(false, envLoader);
        URL xml = findXML(cls);
        // we have to parse metadata up-front to register persistence unit
        // defaults and system callbacks
        ClassMetaData meta;
        boolean parsedXML = false;
        if (_unparsed != null && !_unparsed.isEmpty()
            && (mode & MODE_META) != 0) {
            for (URL url : _unparsed)
                parseXML(url, cls, mode, envLoader);
            parsedXML = _unparsed.contains(xml);
            _unparsed.clear();
            // XML process check
            meta = repos.getCachedMetaData(cls);
            if (meta != null && (meta.getSourceMode() & mode) == mode) {
                validateStrategies(meta);
                return;
            }
        }
        // might have been looking for system-level query
        if (cls == null)
            return;
        // we may still need to parse XML if this is a redeploy of a class, or
        // if we're in strict query-only mode
        if (!parsedXML && xml != null) {
            parseXML(xml, cls, mode, envLoader);
            // XML process check
            meta = repos.getCachedMetaData(cls);
            if (meta != null && (meta.getSourceMode() & mode) == mode) {
                validateStrategies(meta);
                return;
            }
        }
        AnnotationPersistenceMetaDataParser parser = getAnnotationParser();
        parser.setEnvClassLoader(envLoader);
        parser.setMode(mode);
        parser.parse(cls);
        meta = repos.getCachedMetaData(cls);
        if (meta != null && (meta.getSourceMode() & mode) == mode)
            validateStrategies(meta);
}

 public  void loadXMLMetaData(FieldMetaData fmd) 
{
        AnnotationPersistenceXMLMetaDataParser parser
            = getXMLAnnotationParser();
        parser.parse(fmd);
}

 protected  void mapPersistentTypeNames(Object rsrc,
    String[] names) 
{
        if (rsrc.toString().endsWith(".class")) {
            if (log.isTraceEnabled())
                log.trace(
                    _loc.get("map-persistent-types-skipping-class", rsrc));
            return;
        } else if (!(rsrc instanceof URL)) {
            if (log.isTraceEnabled())
                log.trace(
                    _loc.get("map-persistent-types-skipping-non-url", rsrc));
            return;
        }
        if (log.isTraceEnabled())
            log.trace(_loc.get(
                "map-persistent-type-names", rsrc, Arrays.asList(names)));
        if (_xml == null)
            _xml = new HashMap< URL, Set >();
        _xml.put((URL) rsrc, new HashSet(Arrays.asList(names)));
        if (_unparsed == null)
            _unparsed = new HashSet< URL >();
        _unparsed.add((URL) rsrc);
}

 protected AnnotationPersistenceMetaDataParser newAnnotationParser() 
{
        return new AnnotationPersistenceMetaDataParser
            (repos.getConfiguration());
}

Create a new metadata parser.

 protected AnnotationPersistenceMetaDataSerializer newAnnotationSerializer() 
{
        return new AnnotationPersistenceMetaDataSerializer
            (repos.getConfiguration());
}

Create a new annotation serializer.

 public ClassArgParser newClassArgParser() 
{
        ClassArgParser parser = new ClassArgParser();
        parser.setMetaDataStructure("package", null, new String[]{
            "entity", "embeddable", "mapped-superclass" }, "class");
        return parser;
}

 protected MetaDataFilter newMetaDataFilter() 
{
        ClassAnnotationMetaDataFilter camdf = new ClassAnnotationMetaDataFilter(
                new Class[] { Entity.class, Embeddable.class,
                        MappedSuperclass.class });
        camdf.setLog(log);
        return camdf;
}

 protected Parser newParser(boolean loading) 
{
        return newXMLParser(loading);
}

 protected Serializer newSerializer() 
{
        return newXMLSerializer();
}

 protected AnnotationPersistenceXMLMetaDataParser newXMLAnnotationParser() 
{
        return new AnnotationPersistenceXMLMetaDataParser
            (repos.getConfiguration());
}

Create a new JAXB XML annotation parser.

 protected XMLPersistenceMetaDataParser newXMLParser(boolean loading) 
{
        return new XMLPersistenceMetaDataParser(repos.getConfiguration());
}

Create a new metadata parser.

 protected XMLPersistenceMetaDataSerializer newXMLSerializer() 
{
        return new XMLPersistenceMetaDataSerializer(repos.getConfiguration());
}

Create a new serializer

 protected  void parse(MetaDataParser parser,
    Class[] cls) 
{
        parse(parser, Collections.singleton(defaultXMLFile()));
}

 public  void setAnnotationParser(AnnotationPersistenceMetaDataParser parser) 
{
        if (_annoParser != null)
            _annoParser.setRepository(null);
        if (parser != null)
            parser.setRepository(repos);
        _annoParser = parser;
}

Set the metadata parser.

 public  void setConfiguration(Configuration conf) 
{

}

 public  void setFieldOverride(boolean field) 
{
                    
        _fieldOverride = field;
}

Whether to use field-level override or class-level override. Defaults to true.

 public  void setInto(Options opts) 
{
        opts.keySet().retainAll(opts.setInto(_def).keySet());
}

 public  void setXMLAnnotationParser(AnnotationPersistenceXMLMetaDataParser parser) 
{
        if (_annoXMLParser != null)
            _annoXMLParser.setRepository(null);
        if (parser != null)
            parser.setRepository(repos);
        _annoXMLParser = parser;
}

Set the JAXB XML annotation parser.

 public  void setXMLParser(XMLPersistenceMetaDataParser parser) 
{
        if (_xmlParser != null)
            _xmlParser.setRepository(null);
        if (parser != null)
            parser.setRepository(repos);
        _xmlParser = parser;
}

Set the metadata parser.

 public  void startConfiguration() 
{

}