Subversion Repositories SmartDukaan

package in.shop2020.storage.bdb;

import in.shop2020.metamodel.core.Entity;
import in.shop2020.metamodel.core.EntityState;
import in.shop2020.util.Utils;


import java.util.Collection;
import java.util.Map;

import com.sleepycat.collections.TransactionRunner;
import com.sleepycat.collections.TransactionWorker;
import com.sleepycat.je.DatabaseException;

public class StorageManager {

    private final ContentDatabase db;
    private final ContentViews views;
    private final TransactionRunner txnRunner;
    private static StorageManager storageUtils;
    private static final String homeDir =  Utils.BERKELEY_DB_PATH;
    
    static{
                synchronized(StorageManager.class){
                        storageUtils = new StorageManager(homeDir);
                }
        }
    
    /**
     * Run the sample program.
     */
    public static void main(String[] args) {

        System.out.println("\nRunning sample: " + StorageManager.class);

        
        try {
                Collection<Entity> entities=  StorageManager.getStorageManager().getEntitisByCategory(10002);
                for(Entity entity: entities){
                        System.out.println(entity.getID());
                }
                //StorageManager.getStorageManager().printEntitis(10002);
        } catch (Exception e) {
            // If an exception reaches this point, the last transaction did not
            // complete.  If the exception is RunRecoveryException, follow
            // the Berkeley DB recovery procedures before running again.
            e.printStackTrace();
        } finally {
                StorageManager.getStorageManager().close();
        }
    }

    public static StorageManager getStorageManager(){
                return storageUtils;
    }
    /**
     * Open the database and views.
     */
    private StorageManager(String homeDir)
        throws DatabaseException {

        db = new ContentDatabase(homeDir);
        views = new ContentViews(db);
        txnRunner = new TransactionRunner(db.getEnvironment());
    }

    
    /**
     * Close the database cleanly.
     */
    public void close() throws DatabaseException {
        db.close();
    }

    
    @SuppressWarnings("unchecked")
        public Collection<Entity> getEntitisByCategory(long categoryId){
        return views.getEntityByCategoryMap().duplicates(categoryId);
        
    }
    
    @SuppressWarnings("unchecked")
        public Map<Long, EntityState> getEntitiesMetadata(){
        return views.getEntityMetadataMap();
    }
    
    public EntityState getEntityMetadata(long entityId){
        return (EntityState) views.getEntityMetadataMap().get(entityId);
    }

    @SuppressWarnings("unchecked")
        public void updateEntityMetadata(EntityState entityMetadata){
        Map states = views.getEntityMetadataMap();
        states.put(new Long(entityMetadata.getID()), entityMetadata);
    }

    
    public void createEntity(Entity entity, EntityState entityMetadata) throws Exception{
        txnRunner.run(new StoreEntity(entity, entityMetadata));
    }
    
    public void deleteEntity(long entityId) throws Exception{
        txnRunner.run(new DeleteEntity(entityId));
    }

    public Entity getEntity(long entityId) throws Exception{
        return (Entity)views.getEntityMap().get(new Long(entityId));
    }
    public void updateEntity(Entity entity) throws Exception{
        Map entities = views.getEntityMap();
                entities.put(new Long(entity.getID()), entity);
    }
        
    @SuppressWarnings("unchecked")
        public Map<Long, Entity> getEntities() throws Exception{
        return views.getEntityMap();
    }

    public Object getDataObject(String dataObjectName) throws Exception{
        return views.getDataObjectMap().get(dataObjectName);
    }
    
    public void storeDataObject(String dataObjectName, Object dataObject) throws Exception{
        Map dataObjects = views.getDataObjectMap();
        dataObjects.put(dataObjectName, dataObject);
    }
    
    public void deleteDataObject(String dataObjectName) throws Exception{
        views.getDataObjectMap().remove(dataObjectName);
    }

    private class DeleteEntity implements TransactionWorker{
        long entityId;
        public DeleteEntity(long entityId) {
                        this.entityId = entityId;
                }

                @Override
                public void doWork() throws Exception {
                        views.getEntityMap().remove(new Long(entityId));
                views.getEntityMetadataMap().remove(entityId);
                }
    }

    
    private class StoreEntity implements TransactionWorker{
        Entity entity;
        EntityState entityMetadata; 
        public StoreEntity(Entity entity, EntityState entityMetadata) {
                        this.entity = entity;
                        this.entityMetadata = entityMetadata;
                        //System.out.println(entity);
                }

                @Override
                public void doWork() throws Exception {
                Map entities = views.getEntityMap();
                entities.put(new Long(entity.getID()), entity);
                
                Map states = views.getEntityMetadataMap();
                states.put(new Long(entityMetadata.getID()), entityMetadata);
                }
    }

}