| gvSIG desktop 1

/* gvSIG. Geographic Information System of the Valencian Government

*

* Copyright (C) 2007-2008 Infrastructures and Transports Department

* of the Valencian Government (CIT)

*

* This program is free software; you can redistribute it and/or

* modify it under the terms of the GNU General Public License

* as published by the Free Software Foundation; either version 2

* of the License, or (at your option) any later version.

*

* This program is distributed in the hope that it will be useful,

* but WITHOUT ANY WARRANTY; without even the implied warranty of

* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

* GNU General Public License for more details.

*

* You should have received a copy of the GNU General Public License

* along with this program; if not, write to the Free Software

* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,

* MA  02110-1301, USA.

*

*/

/*

* AUTHORS (In addition to CIT):

* 2008 IVER T.I   {{Task}}

*/

/**

 *

 */

package org.gvsig.data;

import java.util.Date;

import org.gvsig.data.exception.CloseException;

import org.gvsig.data.exception.DataException;

import org.gvsig.data.exception.OpenException;

import org.gvsig.data.exception.ResourceChangedException;

import org.gvsig.util.observer.Observable;

import org.gvsig.util.observer.IObservable;

import org.gvsig.util.observer.IObserver;

/**

 * @author jmvivo

 *

 */

public abstract class Resource implements IObservable{

        private int referenceCount;

        private Observable observable = new Observable();

        protected Date lastTimeOpen = null;

        public abstract String description();

        public abstract String getName();

        protected abstract String generateKey();

        public final String getKey(){

                if (this.key == null){

                        this.key = this.generateKey();

                }

                return this.key;

        }

        protected abstract void doChanged();

        private String key=null;

        private boolean opened;

        public final void changed(IDataStore store) {

                doChanged();

                observable.notifyObservers(

                                this,

                                new ResourceNotification(this,IResourceNotification.CHANGED,store));

        }

        public final void changed() {

                observable.notifyObservers(

                                this,

                                new ResourceNotification(this,IResourceNotification.CHANGED));

        }

        public synchronized final void close() throws CloseException{

                if (!this.isOpen())

                        return;

                doClose();

                observable.notifyObservers(

                                this,

                                new ResourceNotification(this,IResourceNotification.CLOSED));

        }

        protected final void dispose()  throws DataException{

                observable.notifyObservers(

                                this,

                                new ResourceNotification(this,IResourceNotification.BEGIN_DISPOSE));

                doDispose();

        }

        protected abstract void doDispose() throws DataException;

        public Date getLastTimeOpen() {

                return new Date(this.lastTimeOpen.getTime());

        }

        /**

         *

         * @return ref count after operation

         */

        void incref() {

                this.referenceCount++;

        }

        protected synchronized final void open()  throws OpenException{

                if (this.isOpen()){

                        return;

                }

                if (doOpen()) {

                        this.updateLastTimeOpen();

                }

                observable.notifyObservers(

                                this,

                                new ResourceNotification(this,IResourceNotification.OPENED));

        }

        protected void updateLastTimeOpen(){

                if (this.lastTimeOpen == null){

                        this.lastTimeOpen = new Date();

                }

                this.lastTimeOpen.setTime(System.currentTimeMillis());

        }

        protected abstract boolean doOpen() throws OpenException;

        /**

         *

         * @return ref count after operation

         */

        void  unref()  throws DataException{

                if (this.referenceCount < 1){

                        throw new DataException("unref in refs < 1");

                }

                this.referenceCount --;

                if (this.referenceCount == 0){

                        this.close();

                }

        }

        public final int getRefencesCount(){

                return referenceCount;

        }

        /* (non-Javadoc)

         * @see org.gvsig.util.observer.IObservable#addObserver(org.gvsig.util.observer.IObserver)

         */

        public void addObserver(IObserver o) {

                this.observable.addObserver(o);

        }

        /* (non-Javadoc)

         * @see org.gvsig.util.observer.IObservable#deleteObserver(org.gvsig.util.observer.IObserver)

         */

        public void deleteObserver(IObserver o) {

                this.observable.deleteObserver(o);

        }

        /* (non-Javadoc)

         * @see org.gvsig.util.observer.IObservable#deleteObservers()

         */

        public void deleteObservers() {

                this.deleteObservers();

        }

        public void addObservers(Observable ob){

                this.observable.addObservers(ob);

        }

        /**

         *

         */

        void preapare() throws DataException{

                try{

                        observable.notifyObservers(

                                        this,

                                        new ResourceNotification(this,IResourceNotification.PREPARE));

                } catch (Exception e){

                        throw new DataException("Perpare exception",e);

                }

        }

        protected synchronized void checkOpen() throws OpenException{

                if (!this.isOpen()){

                        this.open();

                } else {

                        this.checkChanged();

                }

        }

        protected abstract void checkChanged() throws ResourceChangedException;

        public boolean isOpen() {

                return this.opened;

        }

        protected void setOpened() {

                this.opened=true;

        }

        protected boolean doClose() throws CloseException {

                this.opened= false;

                return true;

        }

}