wamblee.org Git - utils/blob - support/general/src/main/java/org/wamblee/persistence/AbstractDetachable.java

   1 /*
   2  * Copyright 2005-2010 the original author or authors.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *      http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16 package org.wamblee.persistence;
  17
  18 /**
  19  * Detachable implementation that takes care of the basic logic for detachable
  20  * objects. All that needs to be done is to implement {@link #load()}.
  21  *
  22  * @param <T>
  23  *            The type of the object to be attached/detached
  24  * @param <Ref>
  25  *            The type of the reference to store when the object is detached.
  26  */
  27 public abstract class AbstractDetachable<T, Ref> implements Detachable<T> {
  28
  29     private T object;
  30     private Ref reference;
  31
  32     /**
  33      * Constructs the detachable.
  34      *
  35      * @param aObject
  36      *            Object.
  37      * @throws IllegalArgumentException
  38      *             When the object passed in is null.
  39      */
  40     protected AbstractDetachable(T aObject) {
  41         if (aObject == null) {
  42             throw new IllegalArgumentException("Object '" + aObject +
  43                 "' is null");
  44         }
  45         object = aObject;
  46         reference = null;
  47     }
  48
  49     /*
  50      * (non-Javadoc)
  51      *
  52      * @see org.wamblee.persistence.Detachable#detach()
  53      */
  54     public void detach() {
  55         if (object == null) {
  56             return; // Nothing to do.
  57         }
  58         reference = getReference(object);
  59         if (reference == null) {
  60             throw new IllegalStateException("Object '" + object +
  61                 "' not persisted yet'");
  62         }
  63         object = null;
  64     }
  65
  66     /*
  67      * (non-Javadoc)
  68      *
  69      * @see org.wamblee.persistence.Detachable#get()
  70      */
  71     public T get() {
  72         if (object == null) {
  73             object = load(reference);
  74             reference = null;
  75         }
  76         return object;
  77     }
  78
  79     /**
  80      * For testing.
  81      *
  82      * @return current object.
  83      */
  84     T getObject() {
  85         return object;
  86     }
  87
  88     /**
  89      * For testing.
  90      *
  91      * @return The reference.
  92      */
  93     Ref getReference() {
  94         return reference;
  95     }
  96
  97     /**
  98      * Loads the object based on a reference.
  99      *
 100      * @param aReference
 101      *            Reference.
 102      * @return Object (may be null ).
 103      */
 104     protected abstract T load(Ref aReference);
 105
 106     /**
 107      * Obtains the reference for a given object.
 108      *
 109      * @param aObject
 110      *            Object.
 111      * @return Reference.
 112      */
 113     protected abstract Ref getReference(T aObject);
 114
 115 }