wireadmin/src/main/java/org/apache/felix/wireadmin/WireImpl.java

/* 
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 *
 *   http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 */

package org.apache.felix.wireadmin;

import java.util.Dictionary;
import java.util.Enumeration;
import java.util.Vector;
import java.util.Date;

import org.osgi.framework.Filter;
import org.osgi.framework.BundleContext;
import org.osgi.framework.ServiceReference;
import org.osgi.framework.Constants;
import org.osgi.framework.InvalidSyntaxException;

import org.osgi.service.wireadmin.Consumer;
import org.osgi.service.wireadmin.Producer;
import org.osgi.service.wireadmin.Wire;
import org.osgi.service.wireadmin.WireConstants;
import org.osgi.service.wireadmin.WireAdminEvent;

/**
 * A connection between a Producer service and a Consumer service.
 *
 * <p>A <tt>Wire</tt> object connects a Producer service
 * to a Consumer service.
 * Both the Producer and Consumer services are identified
 * by their unique <tt>service.pid</tt> values.
 * The Producer and Consumer services may communicate with
 * each other via <tt>Wire</tt> objects that connect them.
 * The Producer service may send updated values to the
 * Consumer service by calling the {@link #update} method.
 * The Consumer service may request an updated value from the
 * Producer service by calling the {@link #poll} method.
 *
 * <p>A Producer service and a Consumer service may be
 * connected through multiple <tt>Wire</tt> objects.
 *
 * <p>Security Considerations. <tt>Wire</tt> objects are available to
 * Producer and Consumer services connected to a given
 * <tt>Wire</tt> object and to bundles which can access the <tt>WireAdmin</tt> service.
 * A bundle must have <tt>ServicePermission[GET,WireAdmin]</tt> to get the <tt>WireAdmin</tt> service to
 * access all <tt>Wire</tt> objects.
 * A bundle registering a Producer service or a Consumer service
 * must have the appropriate <tt>ServicePermission[REGISTER,Consumer|Producer]</tt> to register the service and
 * will be passed <tt>Wire</tt> objects when the service object's
 * <tt>consumersConnected</tt> or <tt>producersConnected</tt> method is called.
 *
 * <p>Scope. Each Wire object can have a scope set with the <tt>setScope</tt> method. This
 * method should be called by a Consumer service when it assumes a Producer service that is
 * composite (supports multiple information items). The names in the scope must be
 * verified by the <tt>Wire</tt> object before it is used in communication. The semantics of the
 * names depend on the Producer service and must not be interpreted by the Wire Admin service.
 *
 * @author <a href="mailto:dev@felix.apache.org">Felix Project Team</a> * 
 */
public class WireImpl implements Wire, java.io.Serializable 
{
	static final long serialVersionUID = -3637966367104019136L;
	
    // Persistent attributes
    
    // p. 327 "The Wire admin object contains a Persistend Identity (PID) for
    // a consumer service and a PID for a producer service" These properties
    // are also contained in the dictionary, but they are stored to optimize
    // access. 
    private String m_producerPID;
    private String m_consumerPID;

    private Dictionary m_properties;
    
    // Transient attributes

	transient private boolean m_isValid = true;
    transient private boolean m_isConnected = false;
    transient private Filter m_filter = null;
    
    transient private ServiceReference m_producerServiceRef;
    transient private Producer m_producer;
    transient private boolean m_producerIsComposite = false;
    transient private String [] m_producerScope = null;
    
    transient private ServiceReference m_consumerServiceRef;	
	transient private Consumer m_consumer;
    transient private boolean m_consumerIsComposite = false;
    transient private String [] m_consumerScope = null;
    
    transient private BundleContext m_bundleContext;
    transient private EventManager m_eventManager;
	transient private Object m_lastValue;
	transient private String[] m_scope;
    
    transient private long m_lastUpdate;    
    transient private boolean m_isFirstUpdate;
    transient FilterDictionary m_dictionary;
    
    /**
     * Constructor with package visibility
     * 
     * @param producerPID
     * @param consumerPID
     * @param properties
     */
	WireImpl(String producerPID, String consumerPID, Dictionary properties)
    {
		m_producerPID = producerPID;
		m_consumerPID = consumerPID;
		m_properties = properties;
		
		// set the scope which is the intersection of strings in the WIREADMIN_PRODUCER_SCOPE properties and the strings in the WIREADMIN_CONSUMER_SCOPE
		m_scope = null;
	}
    
    /**
     * Method called after construction and after deserialization
     * 
     * @param ctxt
     * @param eventManager
     */
    void initialize(BundleContext ctxt, EventManager eventManager)
    {
        m_isValid = true;
        m_isConnected = false;

        m_bundleContext = ctxt;
        m_eventManager = eventManager;
        
        m_lastValue = null;
        
        m_lastUpdate = 0;
        
        m_isFirstUpdate = true;
        
        /*
        if(m_date == null)
        {
            m_date = new Date();
        }
        */
        m_dictionary = new FilterDictionary();
    }

	/**
	 * Return the state of this <tt>Wire</tt> object.
	 *
	 * <p>A connected <tt>Wire</tt> must always be disconnected before
	 * becoming invalid.
	 *
	 * @return <tt>false</tt> if this <tt>Wire</tt> object is invalid because it
	 * has been deleted via {@link WireAdmin#deleteWire};
	 * <tt>true</tt> otherwise.
	 */
	public boolean isValid() 
    {
		return m_isValid;
	}

	/**
	 * Return the connection state of this <tt>Wire</tt> object.
	 *
	 * <p>A <tt>Wire</tt> is connected after the Wire Admin service receives
	 * notification that the Producer service and
	 * the Consumer service for this <tt>Wire</tt> object are both registered.
	 * This method will return <tt>true</tt> prior to notifying the Producer
	 * and Consumer services via calls
	 * to their respective <tt>consumersConnected</tt> and <tt>producersConnected</tt>
	 * methods.
	 * <p>A <tt>WireAdminEvent</tt> of type {@link WireAdminEvent#WIRE_CONNECTED}
	 * must be broadcast by the Wire Admin service when
	 * the <tt>Wire</tt> becomes connected.
	 *
	 * <p>A <tt>Wire</tt> object
	 * is disconnected when either the Consumer or Producer
	 * service is unregistered or the <tt>Wire</tt> object is deleted.
	 * <p>A <tt>WireAdminEvent</tt> of type {@link WireAdminEvent#WIRE_DISCONNECTED}
	 * must be broadcast by the Wire Admin service when
	 * the <tt>Wire</tt> becomes disconnected.
	 *
	 * @return <tt>true</tt> if both the Producer and Consumer
	 * for this <tt>Wire</tt> object are connected to the <tt>Wire</tt> object;
	 * <tt>false</tt> otherwise.
	 */
	public boolean isConnected() 
    {
		return m_isConnected;
	}

	/**
	 * Return the list of data types understood by the
	 * Consumer service connected to this <tt>Wire</tt> object. Note that
	 * subclasses of the classes in this list are acceptable data types as well.
	 *
	 * <p>The list is the value of the {@link WireConstants#WIREADMIN_CONSUMER_FLAVORS}
	 * service property of the
	 * Consumer service object connected to this object. If no such
	 * property was registered or the type of the property value is not
	 * <tt>Class[]</tt>, this method must return <tt>null</tt>.
	 *
	 * @return An array containing the list of classes understood by the
	 * Consumer service or <tt>null</tt> if
	 * the <tt>Wire</tt> is not connected,
	 * or the consumer did not register a {@link WireConstants#WIREADMIN_CONSUMER_FLAVORS} property
	 * or the value of the property is not of type <tt>Class[]</tt>.
	 */

	public Class[] getFlavors() 
    {
        if(isConnected())
        {
            try
            {
                return (Class [])m_consumerServiceRef.getProperty(WireConstants.WIREADMIN_CONSUMER_FLAVORS);
            }
            catch(ClassCastException ex)
            {
                return null;
            }
        }
        else
        {
            return null;

        }
	}

	/**
	 * Update the value.
	 *
	 * <p>This methods is called by the Producer service to
	 * notify the Consumer service connected to this <tt>Wire</tt> object
	 * of an updated value.
	 * <p>If the properties of this <tt>Wire</tt> object contain a
	 * {@link WireConstants#WIREADMIN_FILTER} property,
	 * then filtering is performed.
	 * If the Producer service connected to this <tt>Wire</tt>
	 * object was registered with the service
	 * property {@link WireConstants#WIREADMIN_PRODUCER_FILTERS}, the
	 * Producer service will perform the filtering according to the rules specified
	 * for the filter. Otherwise, this <tt>Wire</tt> object
	 * will perform the filtering of the value.
	 * <p>If no filtering is done, or the filter indicates the updated value should
	 * be delivered to the Consumer service, then
	 * this <tt>Wire</tt> object must call
	 * the {@link Consumer#updated} method with the updated value.
	 * If this <tt>Wire</tt> object is not connected, then the Consumer
	 * service must not be called and the value is ignored.<p>
	 * If the value is an <tt>Envelope</tt> object, and the scope name is not permitted, then the
	 * <tt>Wire</tt> object must ignore this call and not transfer the object to the Consumer
	 * service.
	 *
	 * <p>A <tt>WireAdminEvent</tt> of type {@link WireAdminEvent#WIRE_TRACE}
	 * must be broadcast by the Wire Admin service after
	 * the Consumer service has been successfully called.
	 *
	 * @param value The updated value. The value should be an instance of
	 * one of the types returned by {@link #getFlavors}.
	 * @see WireConstants#WIREADMIN_FILTER
	 */
	public void update(Object value) 
    {
        // TODO Implement Access Control (p. 338)
		if (isConnected())
        {       
            if(m_producerIsComposite == true)
            {
                // TODO Implement update for composite producers
                WireAdminImpl.traceln("WireImpl.update: update for composite producers not yet implemented");
                return;
            }
            else // not a composite (Note: p. 341 "Filtering for composite producer services is not supported")
            {
                //long time = m_date.getTime();
                long time = new Date().getTime();
                
                // We ignore filtering the first time...
                if(m_isFirstUpdate == false && m_filter != null)
                {
                    // If the Producer service was registered with the WIREADMIN_PRODUCER_FILTERS  
                    // service property indicating that the Producer service will perform the data 
                    // filtering then the Wire object will not perform data filtering. Otherwise, 
                    // the Wire object must perform basic filtering.
                    try
                    {
                        m_dictionary.reset(value,time);
                        if(!m_filter.match(m_dictionary))
                        {
                            WireAdminImpl.traceln("### Update rejected ("+m_properties.get(WireConstants.WIREADMIN_PID)+") filter evaluated to false:"+m_filter);
                            WireAdminImpl.traceln("  WIREVALUE_CURRENT.class"+m_dictionary.get(WireConstants.WIREVALUE_CURRENT).getClass().getName());
                            WireAdminImpl.traceln("  WIREVALUE_CURRENT="+m_dictionary.get(WireConstants.WIREVALUE_CURRENT));
                            WireAdminImpl.traceln("  WIREVALUE_PREVIOUS="+m_dictionary.get(WireConstants.WIREVALUE_PREVIOUS));
                            WireAdminImpl.traceln("  WIREVALUE_DELTA_ABSOLUTE="+m_dictionary.get(WireConstants.WIREVALUE_DELTA_ABSOLUTE));
                            WireAdminImpl.traceln("  WIREVALUE_DELTA_RELATIVE="+m_dictionary.get(WireConstants.WIREVALUE_DELTA_RELATIVE));
                            WireAdminImpl.traceln("  WIREVALUE_ELAPSED="+m_dictionary.get(WireConstants.WIREVALUE_ELAPSED));
                            return;
                        }
                    }
                    catch(Exception ex)
                    {
                        // Could happen...
                        WireAdminImpl.trace(ex);
                    }
    
                }
                try
                {
        			m_consumer.updated(this, value);
                    if(m_isFirstUpdate == true)
                    {
                        m_isFirstUpdate = false;
                    }
                    m_lastUpdate = time;
                    m_lastValue = value;
                    // Fire event
                    m_eventManager.fireEvent(WireAdminEvent.WIRE_TRACE,this);
                }
                catch(Exception ex)
                {
                    m_eventManager.fireEvent(WireAdminEvent.CONSUMER_EXCEPTION,this,ex);
                }
            }
        }
	}

	/**
	 * Poll for an updated value.
	 *
	 * <p>This methods is normally called by the Consumer service to
	 * request an updated value from the Producer service
	 * connected to this <tt>Wire</tt> object.
	 * This <tt>Wire</tt> object will call
	 * the {@link Producer#polled} method to obtain an updated value.
	 * If this <tt>Wire</tt> object is not connected, then the Producer
	 * service must not be called.<p>
	 *
	 * If this <tt>Wire</tt> object has a scope, then this method
	 * must return an array of <tt>Envelope</tt> objects. The objects returned must
	 * match the scope of this object. The <tt>Wire</tt> object must remove
	 * all <tt>Envelope</tt> objects with a scope name that is not in the <tt>Wire</tt> object's scope.
	 * Thus, the list of objects returned
	 * must only contain <tt>Envelope</tt> objects with a permitted scope name. If the
	 * array becomes empty, <tt>null</tt> must be returned.
	 *
	 * <p>A <tt>WireAdminEvent</tt> of type {@link WireAdminEvent#WIRE_TRACE}
	 * must be broadcast by the Wire Admin service after
	 * the Producer service has been successfully called.
	 *
	 * @return A value whose type should be one of the types
	 * returned by {@link #getFlavors}, <tt>Envelope[]</tt>, or <tt>null</tt> if
	 * the <tt>Wire</tt> object is not connected,
	 * the Producer service threw an exception, or
	 * the Producer service returned a value which is not an instance of
	 * one of the types returned by {@link #getFlavors}.
	 */
	public Object poll() {
        // p.330 "Update filtering must not apply to polling"
		if (isConnected()) 
        {
            try
            {
    			Object value = m_producer.polled(this);
                Class []flavors = getFlavors();
                
                boolean valueOk = false;
                
                // Test if the value is ok with respect to the flavors understood by
                // the consumer
                for(int i=0; i<flavors.length; i++)
                {
                    Class currentClass = flavors[i];
                    if(currentClass.isInstance(value))
                    {
                        valueOk = true;
                    }                    
                }
                if(valueOk)
                {
                    m_eventManager.fireEvent(WireAdminEvent.WIRE_TRACE,this);
                    m_lastValue = value;
        			return m_lastValue;
                }
                else
                {
                    WireAdminImpl.traceln("WireImpl.poll: value returned by producer is not undestood by consumer");
                    return null;
                }
            }
            catch(Exception ex)
            {
                m_eventManager.fireEvent(WireAdminEvent.PRODUCER_EXCEPTION,this,ex);
                return null;
            }
		} 
        else
        {
            // p. 333 "If the poll() method on the wire object is called and the
            // producer is unregistered it must return a null value"
			return null;
        }
	}

	/**
	 * Return the last value sent through this <tt>Wire</tt> object.
	 *
	 * <p>The returned value is the most recent, valid value passed to the
	 * {@link #update} method or returned by the {@link #poll} method
	 * of this object. If filtering is performed by this <tt>Wire</tt> object,
	 * this methods returns the last value provided by the Producer service. This
	 * value may be an <tt>Envelope[]</tt> when the Producer service
	 * uses scoping. If the return value is an Envelope object (or array), it
	 * must be verified that the Consumer service has the proper WirePermission to see it.
	 *
	 * @return The last value passed though this <tt>Wire</tt> object
	 * or <tt>null</tt> if no valid values have been passed or the Consumer service has no permission.
	 */
	public Object getLastValue() 
    {
		return m_lastValue;
	}

	/**
	 * Return the wire properties for this <tt>Wire</tt> object.
	 *
	 * @return The properties for this <tt>Wire</tt> object.
	 * The returned <tt>Dictionary</tt> must be read only.
	 */
	public Dictionary getProperties() 
    {
		return m_properties;
	}

	/**
	 * Return the calculated scope of this <tt>Wire</tt> object.
	 *
	 * The purpose of the <tt>Wire</tt> object's scope is to allow a Producer
	 * and/or Consumer service to produce/consume different types
	 * over a single <tt>Wire</tt> object (this was deemed necessary for efficiency
	 * reasons). Both the Consumer service and the
	 * Producer service must set an array of scope names (their scope) with
	 * the service registration property <tt>WIREADMIN_PRODUCER_SCOPE</tt>, or <tt>WIREADMIN_CONSUMER_SCOPE</tt> when they can
	 * produce multiple types. If a Producer service can produce different types, it should set this property
	 * to the array of scope names it can produce, the Consumer service
	 * must set the array of scope names it can consume. The scope of a <tt>Wire</tt>
	 * object is defined as the intersection of permitted scope names of the
	 * Producer service and Consumer service.
	 * <p>If neither the Consumer, or the Producer service registers scope names with its
	 * service registration, then the <tt>Wire</tt> object's scope must be <tt>null</tt>.
	 * <p>The <tt>Wire</tt> object's scope must not change when a Producer or Consumer services
	 * modifies its scope.
	 * <p>A scope name is permitted for a Producer service when the registering bundle has
	 * <tt>WirePermission[PRODUCE]</tt>, and for a Consumer service when
	 * the registering bundle has <tt>WirePermission[CONSUME]</tt>.<p>
	 * If either Consumer service or Producer service has not set a <tt>WIREADMIN_*_SCOPE</tt> property, then
	 * the returned value must be <tt>null</tt>.<p>
	 * If the scope is set, the <tt>Wire</tt> object must enforce the scope names when <tt>Envelope</tt> objects are
	 * used as a parameter to update or returned from the <tt>poll</tt> method. The <tt>Wire</tt> object must then
	 * remove all <tt>Envelope</tt> objects with a scope name that is not permitted.
	 *
	 * @return A list of permitted scope names or null if the Produce or Consumer service has set no scope names.
	 */
	public String[] getScope() 
    {
		return m_scope;
	}

	/**
	 * Return true if the given name is in this <tt>Wire</tt> object's scope.
	 *
	 * @param name The scope name
	 * @return true if the name is listed in the permitted scope names
	 */
	public boolean hasScope(String name) 
    {
		if (m_scope != null) 
        {
			for (int i = 0; i < m_scope.length; i++) 
            {
				if (name.equals(m_scope[i])) 
                {
					return true;
				}
			}
		}
		return false;
	}

	/**
	 * @see java.lang.Object#toString()
	 */
	public String toString() 
    {
		return super.toString()
			+ ":["
			+ getProperties().get(WireConstants.WIREADMIN_PID)
			+ ","
			+ getProperties().get(WireConstants.WIREADMIN_PRODUCER_PID)
			+ ","
			+ getProperties().get(WireConstants.WIREADMIN_CONSUMER_PID)
			+ "]";
	}

    /**
     * Bind the consumer.
     * 
     * @param consumer A <tt>ServiceReference</tt> corresponding to the consumer service
     */
    void bindConsumer(ServiceReference consumerRef)
    {
        if(m_consumerServiceRef != null)
        {
            WireAdminImpl.traceln("WireImpl: consumer already bound!");
            return;
        }
        
        // Pid must be present
        if(consumerRef.getProperty(Constants.SERVICE_PID) == null)
        {
            WireAdminImpl.traceln("WireImpl: Consumer service has no PID "+consumerRef);
            return;
        }
        
        // Flavors must be present
        if(consumerRef.getProperty(WireConstants.WIREADMIN_CONSUMER_FLAVORS) == null)
        {
            WireAdminImpl.traceln("WireImpl: Consumer service has no WIREADMIN_CONSUMER_FLAVORS "+consumerRef);
            return;
        }

        // Is this a composite?
        if(consumerRef.getProperty(WireConstants.WIREADMIN_CONSUMER_COMPOSITE) != null)
        {
            m_consumerIsComposite = true;
            m_consumerScope = (String []) consumerRef.getProperty(WireConstants.WIREADMIN_CONSUMER_SCOPE);

        }

        m_consumerServiceRef = consumerRef;
        m_consumer = (Consumer) m_bundleContext.getService(consumerRef);
        
        if(m_producer != null)
        {
            if(m_producerIsComposite)
            {
                if(matchComposites() == false)
                {
                    WireAdminImpl.traceln("WireImpl.bindConsumer : warning composite identities do not match");
                }
            }
            m_isConnected = true;
            m_eventManager.fireEvent(WireAdminEvent.WIRE_CONNECTED,this);
        }
    }
    
    /**
     * Unbind the consumer
     *
     */
    void unbindConsumer()
    {
    	// This test is made because knopflerfish doesn't support ungetService(null);
    	if(m_consumerServiceRef != null)
    	{
	        m_bundleContext.ungetService(m_consumerServiceRef);
	        if(m_isConnected)
	        {
	            m_isConnected = false;
	            m_eventManager.fireEvent(WireAdminEvent.WIRE_DISCONNECTED,this);
	        }
	        m_consumer = null;
	        m_consumerServiceRef = null;
    	}
    }
    
    /**
     * Bind the producer
     * 
     * @param producer A <tt>ServiceReference</tt> corresponding to the producer service
     */
    void bindProducer(ServiceReference producerRef)
    {
        if(m_producerServiceRef != null)
        {
            WireAdminImpl.traceln("WireImpl: producer already bound!");
            return;
        }
        
        // Pid must be present
        if(producerRef.getProperty(Constants.SERVICE_PID) == null)
        {
            WireAdminImpl.traceln("WireImpl.bindProducer: Producer service has no PID "+producerRef);
            return;
        }

        // Flavors must be present
        if(producerRef.getProperty(WireConstants.WIREADMIN_PRODUCER_FLAVORS) == null)
        {
            WireAdminImpl.traceln("WireImpl: Consumer service has no WIREADMIN_PRODUCER_FLAVORS "+producerRef);
            return;
        }

        // Is this a composite?
        if(producerRef.getProperty(WireConstants.WIREADMIN_PRODUCER_COMPOSITE) != null)
        {
            m_producerIsComposite = true;
            m_producerScope = (String []) producerRef.getProperty(WireConstants.WIREADMIN_PRODUCER_SCOPE);
        }

        m_producerServiceRef = producerRef;
        m_producer = (Producer) m_bundleContext.getService(producerRef);
        
        // p. 329 " If this property (wireadmin.producer.filters) is not set,
        // the Wire object must filter according to the description in CompositeObjects"
        if(producerRef.getProperty(WireConstants.WIREADMIN_PRODUCER_FILTERS) == null)
        {
            String filter = (String) m_properties.get(WireConstants.WIREADMIN_FILTER);
            if(filter != null)
            {
                try
                {
                    m_filter = m_bundleContext.createFilter(filter);
                }
                catch(InvalidSyntaxException ex)
                {
                    WireAdminImpl.traceln("WireImpl.bindProducer: Ignoring filter with invalid syntax "+filter);                    
                }
            }
        }
        
        if(m_consumer != null)
        {
            if(m_consumerIsComposite)
            {
                if(matchComposites() == false)
                {
                    WireAdminImpl.traceln("WireImpl.bindProducer : warning composite identities do not match");
                }
            }
            m_isConnected = true;
            // fire the corresponding event
            m_eventManager.fireEvent(WireAdminEvent.WIRE_CONNECTED,this);
        }
    }
    
    /**
     * Unbind the producer
     *
     */
    void unbindProducer()
    {
    	if(m_producerServiceRef != null)
    	{
	        m_bundleContext.ungetService(m_producerServiceRef);
	        if(m_isConnected)
	        {
	            m_isConnected = false;
	            // fire the corresponding event
	            m_eventManager.fireEvent(WireAdminEvent.WIRE_DISCONNECTED,this);
	        }
	        m_producer = null;
	        m_producerServiceRef = null;
    	}
    }

    /**
     * Check if composites match. Match occurs when "at least one equal composite identity is
     * listed on both the Producer and Consmer composite identity service property" (p. 336)
     * 
     * @return <tt>true</tt> if they match, <tt>false</tt>otherwise
     */    
    private boolean matchComposites()
    {
        String [] producerIdentities = (String []) m_producerServiceRef.getProperty(WireConstants.WIREADMIN_PRODUCER_COMPOSITE);
        String [] consumerIdentities = (String []) m_producerServiceRef.getProperty(WireConstants.WIREADMIN_PRODUCER_COMPOSITE);
        
        boolean match = false;
        
        // confirm matching
        
        for(int i = 0; i< producerIdentities.length; i++)
        {
            String currentProducerIdentity = producerIdentities [i]; 
            for(int j = 0; j < consumerIdentities.length; j++)
            {
                String currentConsumerIdentity = consumerIdentities [j];
                if (currentProducerIdentity.equals(currentConsumerIdentity))
                {
                    match = true;
                    break;
                }
            }
        }
        
        // setup wire scope
        
        if (m_consumerScope != null && m_producerScope != null)
        {
            // p. 337 "It is allowed to register with a wildcard, indicating that all scopenames
            // are supported. In that case, the WIREADMIN_SCOPE_ALL ({"*"}) should be registered as the
            // scope of the serivce. The WireObject's scope is then fully defined by the
            // other service connected to the wire object
            if(m_consumerScope.length == 1 && m_consumerScope[0].equals("*"))
            {
                m_scope = m_producerScope;
            }
            else if(m_producerScope.length == 1 && m_producerScope[0].equals("*"))
            {
                m_scope = m_consumerScope;
            }
            else
            {
                /*
                // TODO Implement wire scope creation based on producer, consumer and wire permissions (p. 338)

                ServiceReference ref = m_bundleContext.getServiceReference(PermissionAdmin.class.getName());
                if(ref != null)
                {
                    PermissionAdmin permAdmin = (PermissionAdmin) m_bundleContext.getService(ref);
                    PermissionInfo [] producerPermissions = permAdmin.getPermissions(m_producerServiceRef.getBundle().getLocation());
                    PermissionInfo [] consumerPermissions = permAdmin.getPermissions(m_consumerServiceRef.getBundle().getLocation()); 
                }
                */
            }
        }
        else
        {
            // p. 337 "Not registering this property (WIREADMIN_CONSUMER_SCOPE or WIREADMIN_PRODUCER_SCOPE)
            // by the Consumer or the Producer service indicates to the WireAdmin service that any
            // Wire object connected to that service must return null for the Wire.getScope() method"
            m_scope = null;
        }
        
        return match;
    }

    /**
     * Called to invalidate the wire
     *
     */
    void invalidate()
    {
    	if(m_isValid)
    	{
	        unbindProducer();
	        unbindConsumer();
	        m_isValid=false;
    	}
    }
    
    /**
     * Update the properties
     * 
     * @param properties new properties
     */
    void updateProperties(Dictionary properties)
    {
        m_properties = properties;
    }

    /**
     * Return the service reference corresponding to the producer
     * 
     * @return a <tt>ServiceReference</tt> corresponding to the producer
     */
    ServiceReference getProducerServiceRef()
    {
        return m_producerServiceRef;
    }

    /**
     * Return the producer service object
     * 
     * @return An <tt>Object</tt> corresponding to the producer
     */
    Producer getProducer()
    {
        return m_producer;
    }

    /**
     * return the producer PID
     * 
     * @return
     */
    String getProducerPID()
    {
        return m_producerPID;
    }

    /**
     * Return the service reference corresponding to the consumer
     * 
     * @return a <tt>ServiceReference</tt> corresponding to the consumer
     */
    ServiceReference getConsumerServiceRef()
    {
        return m_consumerServiceRef;
    }

    /**
     * Returns the consumer service object
     * 
     * @return An <tt>Object</tt> corresponding to the consumer
     */
    Consumer getConsumer()
    {
        return m_consumer;
    }

    /**
     * return the consumer PID
     * 
     * @return
     */
    String getConsumerPID()
    {
        return m_consumerPID;
    }
    
    /**
     * This inner class implements a dictionary that is used to filter out values
     * during calls to update. This design choice was favored to avoid constructing
     * a new dictionary for every call to update and to avoid doing unnecessary
     * calculations.
     */
    class FilterDictionary extends Dictionary
    {
        private Object m_value;
        private long m_time;
        
        /**
         * Must be called prior to evaluating the filter
         * 
         * @param value
         * @param time
         */
        void reset(Object value, long time)
        {
            m_value = value;
            m_time = time;
        }
        
        /**
         * 
         */
        public Object get(Object key)
        {
            if(key.equals(WireConstants.WIREVALUE_CURRENT))
            {
                return m_value;
            }
            else if(key.equals(WireConstants.WIREVALUE_PREVIOUS))
            {
                return m_lastValue;
            }
            else if(m_value instanceof Number && key.equals(WireConstants.WIREVALUE_DELTA_ABSOLUTE))
            {
                return null;
            }
            else if(m_value instanceof Number && key.equals(WireConstants.WIREVALUE_DELTA_RELATIVE))
            {
                return null;
            }
            else if(key.equals(WireConstants.WIREVALUE_ELAPSED))
            {
                if(m_lastUpdate == 0)
                {
                    return new Long(0);    
                }
                else
                {
                    long delay = m_time - m_lastUpdate;
                    //System.out.println("### delay = "+(delay));
                    return new Long(delay);
                }
            }
            else
            {
            	WireAdminImpl.traceln("### key not found:"+key);
                return null;
            }
        }

        /**
         * Never empty
         */
        public boolean isEmpty()
        {
            return false;       
        }
        
        /**
         * Remove not supported
         */
        public Object remove(Object obj)
        {
            return null;
        }
        
        /**
         * Size is static
         */
        public int size()
        {
            return 5;
        }
        
        /**
         * Put not supported
         */
        public Object put(Object key, Object value)
        {
            return null;
        }
        
        /**
         * 
         */
        public Enumeration keys()
        {
        	Vector keys=new Vector();
        	
        	keys.addElement(WireConstants.WIREVALUE_ELAPSED);
        	keys.addElement(WireConstants.WIREVALUE_CURRENT);
        	keys.addElement(WireConstants.WIREVALUE_PREVIOUS);
        	keys.addElement(WireConstants.WIREVALUE_DELTA_ABSOLUTE);
        	keys.addElement(WireConstants.WIREVALUE_DELTA_RELATIVE);
        	
        	return keys.elements();
        }
        
        /**
         * Not supported
         */
        public Enumeration elements()
        {
            return null;
        }
    }
}