public EntityManagerFactoryImpl() 
{

}

Default constructor provided for auto-instantiation.

 public EntityManagerFactoryImpl(BrokerFactory factory) 
{
        setBrokerFactory(factory);
}

Supply delegate on construction.

 public  void addLifecycleListener(Object listener,
    Class classes) 
{
        _factory.addLifecycleListener(listener, classes);
}

 public  void addTransactionListener(Object listener) 
{
        _factory.addTransactionListener(listener);
}

 public  void close() 
{
        _factory.close();
}

 public OpenJPAEntityManagerSPI createEntityManager() 
{
        return createEntityManager(null);
}

 public OpenJPAEntityManagerSPI createEntityManager(Map props) 
{
        if (props == null)
            props = Collections.EMPTY_MAP;
        else if (!props.isEmpty())
            props = new HashMap(props);
        OpenJPAConfiguration conf = getConfiguration();
        String user = (String) Configurations.removeProperty
            ("ConnectionUserName", props);
        if (user == null)
            user = conf.getConnectionUserName();
        String pass = (String) Configurations.removeProperty
            ("ConnectionPassword", props);
        if (pass == null)
            pass = conf.getConnectionPassword();
        String str = (String) Configurations.removeProperty
            ("TransactionMode", props);
        boolean managed;
        if (str == null)
            managed = conf.isTransactionModeManaged();
        else {
            Value val = conf.getValue("TransactionMode");
            managed = Boolean.parseBoolean(val.unalias(str));
        }
        Object obj = Configurations.removeProperty("ConnectionRetainMode", 
            props);
        int retainMode;
        if (obj instanceof Number)
            retainMode = ((Number) obj).intValue();
        else if (obj == null)
            retainMode = conf.getConnectionRetainModeConstant();
        else {
            Value val = conf.getValue("ConnectionRetainMode");
            try {
                retainMode = Integer.parseInt(val.unalias((String) obj));
            } catch (Exception e) {
                throw new ArgumentException(_loc.get("bad-em-prop",
                    "openjpa.ConnectionRetainMode", obj),
                    new Throwable[]{ e }, obj, true);
            }
        }
        Broker broker = _factory.newBroker(user, pass, managed, retainMode,
            false);
        // add autodetach for close and rollback conditions to the configuration
        broker.setAutoDetach(AutoDetach.DETACH_CLOSE, true);
        broker.setAutoDetach(AutoDetach.DETACH_ROLLBACK, true);
        broker.setDetachedNew(false);
        OpenJPAEntityManagerSPI em = newEntityManagerImpl(broker);
        // allow setting of other bean properties of EM
        String[] prefixes = ProductDerivations.getConfigurationPrefixes();
        List< RuntimeException > errs = null;
        Method setter;
        String prop, prefix;
        Object val;
        for (Map.Entry entry : (Set< Map.Entry >) props.entrySet()) {
            prop = (String) entry.getKey();
            prefix = null;
            for (int i = 0; i <  prefixes.length; i++) {
                prefix = prefixes[i] + ".";
                if (prop.startsWith(prefix))
                    break;
                prefix = null; 
            } 
            if (prefix == null)
                continue; 
            prop = prop.substring(prefix.length());
            try {
                setter = Reflection.findSetter(em.getClass(), prop, true);
            } catch (OpenJPAException ke) {
                if (errs == null)
                    errs = new LinkedList< RuntimeException >();
                errs.add(PersistenceExceptions.toPersistenceException(ke));
                continue;
            }
            val = entry.getValue();
            try {
                if (val instanceof String) {
                    if ("null".equals(val))
                        val = null;
                    else
                        val = Strings.parse((String) val,
                            setter.getParameterTypes()[0]);
                }
                Reflection.set(em, setter, val);
            } catch (Throwable t) {
                while (t.getCause() != null)
                    t = t.getCause();
                ArgumentException err = new ArgumentException(_loc.get
                    ("bad-em-prop", prop, entry.getValue()),
                    new Throwable[]{ t }, null, true);
                if (errs == null)
                    errs = new LinkedList< RuntimeException >();
                errs.add(err);
            }
        }
        if (errs != null) {
            em.close();
            if (errs.size() == 1)
                throw errs.get(0);
            throw new ArgumentException(_loc.get("bad-em-props"),
                errs.toArray(new Throwable[errs.size()]),
                null, true);
        }
        return em;
}

 public boolean equals(Object other) 
{
        if (other == this)
            return true;
        if (!(other instanceof EntityManagerFactoryImpl))
            return false;
        return _factory.equals(((EntityManagerFactoryImpl) other)._factory);
}

 public BrokerFactory getBrokerFactory() 
{
        return _factory.getDelegate();
}

Delegate.

 public OpenJPAConfiguration getConfiguration() 
{
        return _factory.getConfiguration();
}

 public Properties getProperties() 
{
        return _factory.getProperties();
}

 public QueryResultCache getQueryResultCache() 
{
        _factory.lock();
        try {
            if (_queryCache == null)
                _queryCache = new QueryResultCacheImpl(_factory.
                    getConfiguration().getDataCacheManagerInstance().
                    getSystemQueryCache());
            return _queryCache;
        } finally {
            _factory.unlock();
        }
}

 public StoreCache getStoreCache() 
{
        _factory.lock();
        try {
            if (_cache == null) {
                OpenJPAConfiguration conf = _factory.getConfiguration();
                _cache = new StoreCacheImpl(this,
                    conf.getDataCacheManagerInstance().getSystemDataCache());
            }
            return _cache;
        } finally {
            _factory.unlock();
        }
}

 public StoreCache getStoreCache(String cacheName) 
{
        return new StoreCacheImpl(this, _factory.getConfiguration().
            getDataCacheManagerInstance().getDataCache(cacheName, true));
}

 public Object getUserObject(Object key) 
{
        return _factory.getUserObject(key);
}

 public int hashCode() 
{
        return _factory.hashCode();
}

 public boolean isOpen() 
{
        return !_factory.isClosed();
}

 protected EntityManagerImpl newEntityManagerImpl(Broker broker) 
{
        return new EntityManagerImpl(this, broker);
}

Create a new entity manager around the given broker.

 public Object putUserObject(Object key,
    Object val) 
{
        return _factory.putUserObject(key, val);
}

 public  void removeLifecycleListener(Object listener) 
{
        _factory.removeLifecycleListener(listener);
}

 public  void removeTransactionListener(Object listener) 
{
        _factory.removeTransactionListener(listener);
}

 public  void setBrokerFactory(BrokerFactory factory) 
{
        _factory = new DelegatingBrokerFactory(factory,
            PersistenceExceptions.TRANSLATOR);
}

Delegate must be provided before use.

 FetchPlan toFetchPlan(Broker broker,
    FetchConfiguration fetch) 
{
        if (fetch == null)
            return null;
        if (fetch instanceof DelegatingFetchConfiguration)
            fetch = ((DelegatingFetchConfiguration) fetch).
                getInnermostDelegate();
        try {
            if (_plan == null) {
                Class storeType = (broker == null) ? null : broker.
                    getStoreManager().getInnermostDelegate().getClass();
                Class cls = _factory.getConfiguration().
                    getStoreFacadeTypeRegistry().
                    getImplementation(FetchPlan.class, storeType, 
                    		FetchPlanImpl.class);
                _plan = cls.getConstructor(FetchConfiguration.class);
            }
            return _plan.newInstance(fetch);
        } catch (InvocationTargetException ite) {
            throw PersistenceExceptions.toPersistenceException
                (ite.getTargetException());
        } catch (Exception e) {
            throw PersistenceExceptions.toPersistenceException(e);
        }
}

Create a store-specific facade for the given fetch configuration. If no facade class exists, we use the default FetchPlan .