path: root/bundles/org.eclipse.wst.wsdl.ui/src/org/eclipse/wst/wsdl/ui/internal/util/ReferenceManager.java

/*******************************************************************************
 * Copyright (c) 2001, 2004 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 * 
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/
package org.eclipse.wst.wsdl.ui.internal.util;
        
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
import java.util.List;

import org.eclipse.emf.common.notify.Adapter;
import org.eclipse.emf.common.notify.Notification;
import org.eclipse.emf.common.notify.Notifier;
import org.eclipse.emf.common.notify.impl.AdapterFactoryImpl;
import org.eclipse.emf.common.notify.impl.AdapterImpl;
import org.eclipse.emf.ecore.EObject;
import org.eclipse.emf.ecore.EStructuralFeature;
import org.eclipse.wst.wsdl.Binding;
import org.eclipse.wst.wsdl.BindingFault;
import org.eclipse.wst.wsdl.BindingOperation;
import org.eclipse.wst.wsdl.Definition;
import org.eclipse.wst.wsdl.Operation;
import org.eclipse.wst.wsdl.PortType;
import org.eclipse.wst.wsdl.WSDLPackage;
import org.eclipse.wst.wsdl.internal.util.WSDLSwitch;


public class ReferenceManager
{                            
  protected static InternalAdapterFactory internalAdapterFactory = new InternalAdapterFactory();

                                                 
  public interface Listener
  {
    public void bindingsChanged( Operation operation);
  }     

            
  public static void adaptDefinition(Definition definition)
  {
    internalAdapterFactory.adapt(definition);
    for (Iterator i = definition.getEBindings().iterator(); i.hasNext(); )
    {
      Binding binding = (Binding)i.next();
      internalAdapterFactory.adaptBinding(binding);
    }
  }

                               
  public static void addBindingListener(Operation operation, Listener listener)
  {                 
    OperationAdapter adapter = (OperationAdapter)internalAdapterFactory.adapt(operation);
    if (adapter != null)
    {
      adapter.addListener(listener); 
    }
  }


  public static void removeBindingListener(Operation operation, Listener listener)
  { 
    OperationAdapter adapter = (OperationAdapter)internalAdapterFactory.adapt(operation);
    if (adapter != null)
    {
      adapter.removeListener(listener); 
    }
  }

  protected static void fireNotificationForPortType(PortType portType)
  {
    // get the adapter for each operation and notify listeners
    if (portType != null)
    {
      for (Iterator i = portType.getEOperations().iterator();  i.hasNext(); )
      {
        fireNotificationForOperation((Operation)i.next());
      }
    }
  }


  protected static void fireNotificationForOperation(Operation operation)
  {
    if (operation != null)
    {
      OperationAdapter adapter = (OperationAdapter)internalAdapterFactory.adapt(operation);
      adapter.fireBindingsChanged();
    }
  }


  public static class InternalAdapterFactory extends AdapterFactoryImpl
  {                     
    public Adapter createAdapter(Notifier target)
    {                     
      WSDLSwitch wsdlSwitch = new WSDLSwitch()
      {                
      	public Object caseBinding(Binding binding)
        {   
          return createBindingAdapter();
	      }

 	      public Object caseBindingFault(BindingFault bindingFault)
        {                                      
          return createBindingFaultAdapter();
        }   

	      public Object caseBindingOperation(BindingOperation bindingOperation)
        {   
          return createBindingOperationAdapter();
	      } 
   
      	public Object caseDefinition(Definition definition)
        {   
          return createDefinitionAdapter();
	      }  

      	public Object caseOperation(Operation operation)
        {   
          return createOperationAdapter();
	      }                
      };   

      Object o = wsdlSwitch.doSwitch((EObject)target);

      Adapter result = null;
      if (o instanceof Adapter)
      {
        result  = (Adapter)o;
      }
      else
      {          
        System.out.println("did not create adapter for target : " + target);
        Thread.dumpStack();
      }                   
      //System.out.println("createAdapter(" + target + ") " + result);
      return result;
    }      
                               
               
  	public Adapter createBindingAdapter()
    {
      return new BindingAdapter();
    }        

 	  public Adapter createBindingFaultAdapter()
    {                                      
      return new BindingFaultAdapter();
    }     

    public Adapter createBindingOperationAdapter()
    {     
      return new BindingOperationAdapter();
    }      

  	public Adapter createDefinitionAdapter() 
    {
		  return new DefinitionAdapter();
	  } 

  	public Adapter createOperationAdapter() 
    {
		  return new OperationAdapter();
	  }                                      

    public Adapter adapt(Notifier target)
    {
      return target != null ? adapt(target, internalAdapterFactory) : null;
    }

    protected void adaptBinding(Binding binding)     
    {
      adapt(binding); 
      for (Iterator i = binding.getEBindingOperations().iterator(); i.hasNext(); )
      {
        BindingOperation bindingOperation = (BindingOperation)i.next();
        adapt(bindingOperation);    
        for (Iterator j = bindingOperation.getEBindingFaults().iterator(); j.hasNext(); )
        {
          BindingFault bindingFault = (BindingFault)j.next();
          adapt(bindingFault);  
        }
      }
    }  
  }  
  

  protected static abstract class BaseAdapter extends AdapterImpl
  {
    public boolean isAdapterForType(Object type)
    {
      return type == internalAdapterFactory;
    }   

    public WSDLPackage getPackage()
    {
      return WSDLPackage.eINSTANCE;                        
    }
  }

    
  // DefinitionAdapter
  //
  protected static class DefinitionAdapter extends BaseAdapter
  {                                                                                  
    public void notifyChanged(Notification msg)
    {                                
      Definition definition = (Definition)getTarget();
                                  
      if ((EStructuralFeature)msg.getFeature() == getPackage().getDefinition_EBindings())
      {                           
        Object newValue = msg.getNewValue();
        switch (msg.getEventType())
        {
          case Notification.ADD:
          {                                 
            handleAdd((Binding)newValue);
            break;
          }
          case Notification.ADD_MANY:
          {
            for (Iterator newValues = ((Collection)newValue).iterator();  newValues.hasNext(); )
            {
              handleAdd((Binding)newValues.next());
            }
            break;
          }       
        }                                           
      }    
    }     

    protected void handleAdd(Binding binding)
    {  
      internalAdapterFactory.adaptBinding(binding);
      PortType portType = binding.getEPortType();
      if (portType != null)
      {
        fireNotificationForPortType(portType);
      }
    }
  }     
          
  
  protected static class BindingAdapter extends BaseAdapter
  {                      
    public void notifyChanged(Notification msg)
    { 
      if ((EStructuralFeature)msg.getFeature() == getPackage().getBinding_EPortType())
      {
        // fireNotifcation for all of the operation of the old and new portType
        fireNotificationForPortType((PortType)msg.getNewValue());
        fireNotificationForPortType((PortType)msg.getOldValue());
      }                                                                        
      else if ((EStructuralFeature)msg.getFeature() == getPackage().getBinding_EBindingOperations())
      {
        // fireNotifcation for all operations that were added or removed
        Object newValue = msg.getNewValue();
        Object oldValue = msg.getNewValue();
        switch (msg.getEventType())
        {
          case Notification.ADD:
          {                                                                    
            handleAdd((BindingOperation)newValue);
            break;
          }
          case Notification.ADD_MANY:
          {
            for (Iterator newValues = ((Collection)newValue).iterator();  newValues.hasNext(); )
            {
              handleAdd((BindingOperation)newValues.next());
            }
            break;
          }       
          case Notification.REMOVE:
          {                                                                    
            handleRemove((BindingOperation)oldValue);
            break;
          }
          case Notification.REMOVE_MANY:
          {
            for (Iterator oldValues = ((Collection)oldValue).iterator();  oldValues.hasNext(); )
            {
              handleRemove((BindingOperation)oldValues.next());
            }
            break;
          }  
        }                  
      }
    }    

    protected void handleAdd(BindingOperation bindingOperation)
    {
      internalAdapterFactory.adapt(bindingOperation);
      Operation operation = ComponentReferenceUtil.computeOperation(bindingOperation);                                                            
      fireNotificationForOperation(operation);
    }               

    protected void handleRemove(BindingOperation bindingOperation)
    {                 
      if (bindingOperation != null)
      {
        Operation operation = ComponentReferenceUtil.computeOperation(bindingOperation);                                                            
        fireNotificationForOperation(operation);
      }
    }   
  }       
  


  protected static class BindingOperationAdapter extends BaseAdapter
  {                                      
    public void notifyChanged(Notification msg)
    {                                
      BindingOperation bindingOperation = (BindingOperation)getTarget();
      Operation operation = ComponentReferenceUtil.computeOperation(bindingOperation);                                                            
      fireNotificationForOperation(operation);
    }                
  }
  

  protected static class BindingFaultAdapter extends BaseAdapter
  {                                  
    public void notifyChanged(Notification msg)
    {                                       
      BindingFault bindingFault = (BindingFault)getTarget();
      BindingOperation bindingOperation = (BindingOperation)bindingFault.eContainer();
      Operation operation = ComponentReferenceUtil.computeOperation(bindingOperation);                                                            
      fireNotificationForOperation(operation);
    }                
  } 
  

  protected static class OperationAdapter extends BaseAdapter 
  {     
    protected Definition definition;
    protected List listeners = new ArrayList();

    public void addListener(Listener listener)
    {
      listeners.add(listener);
    }

    public void removeListener(Listener listener)
    {
      listeners.remove(listener);
    }   

    public void fireBindingsChanged()
    {                            
      Operation operation = (Operation)getTarget();
      for (Iterator i = listeners.iterator(); i.hasNext(); )
      {                                   
        Listener listener = (Listener)i.next();
        listener.bindingsChanged(operation);
      }
    }         
  }   
}