/* (c) Copyright 2003 Caleigo AB, All rights reserved. 
    * 
    * This library is free software; you can redistribute it and/or
    * modify it under the terms of the GNU Lesser General Public
    * License as published by the Free Software Foundation; either
    * version 2.1 of the License, or (at your option) any later version.
    * 
    * This library 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
   * Lesser General Public License for more details.
   * 
   * You should have received a copy of the GNU Lesser General Public
   * License along with this library; if not, write to the Free Software
   * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
   *  
   */
  
  package org.caleigo.core;
  
  import org.caleigo.core.event.*;
  
  /*** A ProxyQualifier acts as a proxy to another Qualifier object that may set 
   * by simple access a methods. All events are forwarded transparently.
   *
   * If a ProxyQualifier does not have a source object it does not qualify any
   * entities of any type, making them effectivelly useless. In other words it 
   * allways returns false on calls to doesSelect, canSelect and canUniquelySelect.
   *
   * @author  Dennis Zikovic
   * @version 1.00
   *
   *//* 
   *
   * WHEN        WHO               WHY & WHAT
   * -----------------------------------------------------------------------------
   * 2001-11-22  Dennis Zikovic    Creation
   */
  public class ProxyQualifier extends Qualifier
  {
      // Data members ------------------------------------------------------------
      private Qualifier mRemoteQualifier;
      
      private transient ProxyRelayListener mRelayListener;
      private transient IProxyListener mProxyListener;
      
      // Constructors ------------------------------------------------------------
      
      /*** Creates new ProxyQualifier
       */
      public ProxyQualifier() 
      {
      }
      
      /*** Creates new ProxyQualifier
       */
      public ProxyQualifier(Qualifier qualifier) 
      {
          this.setRemoteQualifier(qualifier);
      }
      
      // Superclass overrides ----------------------------------------------------
      
      /*** This abstract method must return true if the qualifier does select the
       * provided entity object.
       */
      public boolean doesQualify(IEntity entity)
      {
          if(mRemoteQualifier!=null)
              return mRemoteQualifier.doesQualify(entity);
          else
              return false;
      }
      
      /*** This abstract method must return true if the qualifier can select 
       * entities of the type defined by the provided entity descriptor.
       */
      public boolean canQualify(IEntityDescriptor entityDescriptor)
      {
          if(mRemoteQualifier!=null)
              return mRemoteQualifier.canQualify(entityDescriptor);
          else
              return false;
      }
      
      /*** This abstract method must return true if the qualifier can select 
       * entities of the type defined by the provided entity descriptor without
       * the nead of any complementary data. No other information than can be
       * accessed through the provided entity descriptor should be neaded if 
       * this method returns true. This validates that the doesQualify method
       * can be called for the called qualifier.
       */
      public boolean canDirectlyQualify(IEntityDescriptor entityDescriptor)
      {
          if(mRemoteQualifier!=null)
              return mRemoteQualifier.canDirectlyQualify(entityDescriptor);
          else
              return false;
      }
     
     /*** This abstract method must return true if the qualifier can uniquely 
      * select entities of the type defined by the provided entity descriptor. 
      * If that is the case then the qualifier is an identity qualifier and can 
      * never qualify more then a single entity instance of the specified type.
      */
     public boolean canUniquelyQualify(IEntityDescriptor entityDescriptor)
     {
         if(mRemoteQualifier!=null)
             return mRemoteQualifier.canUniquelyQualify(entityDescriptor);
         else
             return false;
     }
     
     /*** The toString method returns an "abstract" expression of what the 
      * qualifier selects. Note that this expresion is only intended for visual
      * aid and is not a valid SQL expresion. 
      */
     public String toString()
     {
         if(mRemoteQualifier!=null)
             return mRemoteQualifier.toString();
         else
             return "(EMPTY PROXY)";
     }
 
     // Access methods ----------------------------------------------------------
     
     /*** Boolean access method that returns true if the proxy has a remote
      * Qualifier if false then getRemoteQualifier() will return null.
      */
     public boolean hasRemoteQualifier()
     {
         return mRemoteQualifier!=null;
     }
     
     /*** Access method that returns the remote Qualifier of the proxy.
      * May return null if the proxy does not currently have a remote.
      */
     public Qualifier getRemoteQualifier()
     {
         return mRemoteQualifier;
     }
     
     /*** Boolean access method that returns true if the proxy has a source
      * Qualifier if false then getSourceQualifier() will return null.
      */
     public boolean hasSourceQualifier()
     {
         return this.getSourceQualifier()!=null;
     }
     
     /*** Access method that returns the source Qualifier of the proxy.
      * May return null if the proxy does not currently have a source Qualifier.
      */
     public Qualifier getSourceQualifier()
     {
         if(mRemoteQualifier==null)
             return null;
         if(mRemoteQualifier instanceof ProxyQualifier)
             return ((ProxyQualifier)mRemoteQualifier).getSourceQualifier();
         else
             return this.getRemoteQualifier();
     }
     
     /*** Optional mutation method that throws an UnsupportedOperationException 
      * if the implementing class does not support the method. Note that setting
      * a new remote qualifier is and should be considered as a structural
      * change in the Qualifier causing a QualifierEvent to be fired.
      */
     public void setRemoteQualifier(Qualifier qualifier)
     {
         // Ignore entity if equal to the current remote entity.
         if(mRemoteQualifier==qualifier)
             return; 
         
         // Remove all listeners in the remote object.
         if(mRemoteQualifier!=null && mRelayListener!=null)
         {
             mRemoteQualifier.removeQualifierListener(mRelayListener);
             if(mRemoteQualifier instanceof ProxyQualifier)
                  ((ProxyQualifier)mRemoteQualifier).removeProxyListener(mRelayListener);
         }
         
         // Update the stored remote entity.
         mRemoteQualifier = qualifier;
         
         // Register listeners on the new remote object.
         if(mRemoteQualifier!=null)
         {
             if(mRelayListener==null)
                 mRelayListener = new ProxyRelayListener();
             mRemoteQualifier.addQualifierListener(mRelayListener);
             if(mRemoteQualifier instanceof ProxyQualifier)
                  ((ProxyQualifier)mRemoteQualifier).addProxyListener(mRelayListener);
         }
         
         // Fire relevant proxy and qualifier events..
         this.fireProxyEvent(ProxyEvent.CHANGED);
         this.fireStructureChangedEvent();
     }
     
     /*** Adds IProxyListener to receive notifications of performed 
      * data operations on the Qualifier object.
      */
     public void addProxyListener(IProxyListener listener)
     {
         mProxyListener = (IProxyListener)CELEventMulticaster.add(mProxyListener, listener);
     }
     
     /*** Removes the specified IProxyListener from the Qualifier object.
      */
     public void removeProxyListener(IProxyListener listener)
     {
         mProxyListener = (IProxyListener)CELEventMulticaster.remove(mProxyListener, listener);
     }
     
     // Help methods ------------------------------------------------------------
     
     /*** Fires a ProxyEvent with the provided operation type to all registered
      * IProxyListener objects.
      */
     protected void fireProxyEvent(int eventType)
     {
         if(mProxyListener==null)
             return;
         else if(eventType == ProxyEvent.CHANGED)
             mProxyListener.remoteChanged(new ProxyEvent(this, eventType));
         else if(eventType == ProxyEvent.EXPANDED)
             mProxyListener.remoteExpanded(new ProxyEvent(this, eventType));
     }
     
     // Nested classes ----------------------------------------------------------
     
     /*** Simple listener class that relays all received events to the listeners
      * registered in the proxy object.
      */
     private class ProxyRelayListener extends RelayListener implements IProxyListener
     {
         public void remoteExpanded(ProxyEvent event)
         {
             if(mProxyListener!=null)
                 mProxyListener.remoteExpanded(event);
         }
         
         public void remoteChanged(ProxyEvent event)
         {
             if(mProxyListener!=null)
                 mProxyListener.remoteChanged(event);
         }
     }
 }