public  void activateEntity(EntityEnterpriseContext ctx) 
{
      activateEntityCommand.execute(ctx);
}

 public  void create() throws Exception 
{
      // Store a reference to this manager in an application level hashtable.
      // This way in the start method other managers will be able to know
      // the other managers.
      HashMap managersMap = (HashMap)getApplicationData(CREATED_MANAGERS);
      if(managersMap == null)
      {
         managersMap = new HashMap();
         putApplicationData(CREATED_MANAGERS, managersMap);
      }
      managersMap.put(container.getBeanMetaData().getEjbName(), this);
}

Does almost nothing because other services such as JDBC data sources may not have been started.

 public Object createBeanClassInstance() throws Exception 
{
      if(createBeanClassInstanceCommand == null)
         throw new IllegalStateException("createBeanClassInstanceCommand == null");
      return createBeanClassInstanceCommand.execute();
}

Returns a new instance of a class which implemnts the bean class.

 public Object createEntity(Method createMethod,
    Object[] args,
    EntityEnterpriseContext ctx) throws CreateException 
{
      Object pk = createEntityCommand.execute(createMethod, args, ctx);
      if(pk == null)
         throw new CreateException("Primary key for created instance is null.");
      return pk;
}

 public  void destroy() 
{
      // On deploy errors, sometimes CMPStoreManager was never initialized!
      if(destroyCommand != null)
      {
         destroyCommand.execute();
      }
      if(readAheadCache != null)
      {
         readAheadCache.destroy();
      }
      readAheadCache = null;
      if(queryManager != null)
      {
         queryManager.clear();
      }
      queryManager = null;
      //Remove proxy from proxy map so UnifiedClassloader may be released
      if(createBeanClassInstanceCommand != null)
      {
         createBeanClassInstanceCommand.destroy();
      } // end of if ()
}

 public Collection findEntities(Method finderMethod,
    Object[] args,
    EntityEnterpriseContext ctx,
    GenericEntityObjectFactory factory) throws FinderException 
{
      return findEntitiesCommand.execute(finderMethod, args, ctx, factory);
}

 public Object findEntity(Method finderMethod,
    Object[] args,
    EntityEnterpriseContext ctx,
    GenericEntityObjectFactory factory) throws FinderException 
{
      return findEntityCommand.execute(finderMethod, args, ctx, factory);
}

 public Object getApplicationData(Object key) 
{
      return ejbModule.getModuleData(key);
}

 public Map getApplicationDataMap() 
{
      return ejbModule.getModuleDataMap();
}

 public Object getApplicationTxData(Object key) 
{
      Map map = getApplicationTxDataMap();
      if(map != null)
      {
         return map.get(key);
      }
      return null;
}

 public Catalog getCatalog() 
{
      return (Catalog)getApplicationData(CATALOG);
}

 public JDBCCommandFactory getCommandFactory() 
{
      return commandFactory;
}

 public EntityContainer getContainer() 
{
                          
      return container;
}

Gets the container for this entity.

 public JDBCAbstractEntityBridge getEntityBridge() 
{
      return entityBridge;
}

 public Object getEntityTxData(Object key) 
{
      return getEntityTxDataMap().get(key);
}

 public JDBCTypeFactory getJDBCTypeFactory() 
{
      return typeFactory;
}

 public JDBCEntityMetaData getMetaData() 
{
      return metaData;
}

 public JDBCQueryManager getQueryManager() 
{
      return queryManager;
}

 public ReadAheadCache getReadAheadCache() 
{
      return readAheadCache;
}

 public  void initEntity(EntityEnterpriseContext ctx) 
{
      initEntityCommand.execute(ctx);
}

 public boolean isModified(EntityEnterpriseContext ctx) 
{
      return entityBridge.isModified(ctx);
}

 public boolean isStoreRequired(EntityEnterpriseContext ctx) 
{
      return isModifiedCommand.execute(ctx);
}

 public  void loadEntity(EntityEnterpriseContext ctx) 
{
      loadEntity(ctx, true);
}

Loads entity. If entity not found NoSuchEntityException is thrown.

 public boolean loadEntity(EntityEnterpriseContext ctx,
    boolean failIfNotFound) 
{
      // is any on the data already in the entity valid
      if(!ctx.isValid())
      {
         if(log.isTraceEnabled())
         {
            log.trace("RESET PERSISTENCE CONTEXT: id=" + ctx.getId());
         }
         entityBridge.resetPersistenceContext(ctx);
      }
      // mark the entity as created; if it was loading it was created
      JDBCEntityBridge.setCreated(ctx);
      return loadEntityCommand.execute(ctx, failIfNotFound);
}

 public  void loadField(JDBCCMPFieldBridge field,
    EntityEnterpriseContext ctx) 
{
      loadEntityCommand.execute(field, ctx);
}

 public Collection loadRelation(JDBCCMRFieldBridge cmrField,
    Object pk) 
{
      return loadRelationCommand.execute(cmrField, pk);
}

 public  void passivateEntity(EntityEnterpriseContext ctx) 
{
      passivateEntityCommand.execute(ctx);
}

 public Object postCreateEntity(Method createMethod,
    Object[] args,
    EntityEnterpriseContext ctx) 
{
      return postCreateEntityCommand.execute(createMethod, args, ctx);
}

 public  void putApplicationData(Object key,
    Object value) 
{
      ejbModule.putModuleData(key, value);
}

 public  void putApplicationTxData(Object key,
    Object value) 
{
      Map map = getApplicationTxDataMap();
      if(map != null)
      {
         map.put(key, value);
      }
}

 public  void putEntityTxData(Object key,
    Object value) 
{
      getEntityTxDataMap().put(key, value);
}

 public  void removeEntity(EntityEnterpriseContext ctx) throws RemoveException, RemoteException 
{
      removeEntityCommand.execute(ctx);
}

 public  void removeEntityTxData(Object key) 
{
      getEntityTxDataMap().remove(key);
}

 public  void scheduleCascadeDelete(List pks) 
{
      CascadeDeleteRegistry registry = (CascadeDeleteRegistry)cascadeDeleteSet.get();
      registry.scheduleAll(pks);
}

Schedules instances for cascade-delete

 public  void setContainer(Container container) 
{
      this.container = (EntityContainer)container;
      if(container != null)
      {
         ejbModule = container.getEjbModule();
         log = Logger.getLogger(
            this.getClass().getName() +
            "." +
            container.getBeanMetaData().getEjbName());
      }
      else
      {
         ejbModule = null;
      }
}

Sets the container for this entity.

 public  void start() throws Exception 
{
      //
      //
      // Start Phase 1: create bridge and commands but
      // don't access other entities
      initStoreManager();
      // If all managers have been started (this is the last manager),
      // complete the other two phases of startup.
      Catalog catalog = getCatalog();
      HashMap managersMap = (HashMap)getApplicationData(CREATED_MANAGERS);
      if(catalog.getEntityCount() == managersMap.size()
         && catalog.getEJBNames().equals(managersMap.keySet()))
      {
         // Make a copy of the managers (for safty)
         ArrayList managers = new ArrayList(managersMap.values());
         //
         //
         // Start Phase 2: resolve relationships
         for(int i = 0; i <  managers.size(); ++i)
         {
            JDBCStoreManager manager = (JDBCStoreManager)managers.get(i);
            manager.resolveRelationships();
         }
         //
         //
         // Start Phase 3: create tables and compile queries
         for(int i = 0; i <  managers.size(); ++i)
         {
            JDBCStoreManager manager = (JDBCStoreManager)managers.get(i);
            manager.startStoreManager();
         }
         // add foreign key constraints
         for(int i = 0; i <  managers.size(); ++i)
         {
            JDBCStoreManager manager = (JDBCStoreManager)managers.get(i);
            manager.startCommand.addForeignKeyConstraints();
         }
      }
}

Bring the store to a fully initialized state

 public  void stop() 
{
      // On deploy errors, sometimes CMPStoreManager was never initialized!
      if(stopCommand != null)
      {
         Map managersMap = (HashMap)getApplicationData(CREATED_MANAGERS);
         while(!managersMap.isEmpty())
         {
            int stoppedInIteration = 0;
            for(Iterator i = managersMap.values().iterator(); i.hasNext();)
            {
               JDBCStoreManager manager = (JDBCStoreManager)i.next();
               if(manager.stopCommand == null || manager.stopCommand.execute())
               {
                  i.remove();
                  ++stoppedInIteration;
               }
            }
            if(stoppedInIteration == 0)
            {
               break;
            }
         }
      }
      readAheadCache.stop();
}

 public  void storeEntity(EntityEnterpriseContext ctx) 
{
      storeEntityCommand.execute(ctx);
      synchronizeRelationData();
}

 public boolean unscheduledCascadeDelete(Object pk) 
{
      CascadeDeleteRegistry registry = (CascadeDeleteRegistry)cascadeDeleteSet.get();
      return registry.unschedule(pk);
}

Unschedules instance cascade delete.