/*
* 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.framework;
import java.util.Collection;
import java.util.Collections;
import java.util.Dictionary;
import java.util.Enumeration;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
import org.apache.felix.framework.ServiceRegistrationImpl.ServiceReferenceImpl;
import org.apache.felix.framework.capabilityset.CapabilitySet;
import org.apache.felix.framework.capabilityset.SimpleFilter;
import org.apache.felix.framework.util.StringMap;
import org.apache.felix.framework.wiring.BundleCapabilityImpl;
import org.osgi.framework.Filter;
import org.osgi.framework.InvalidSyntaxException;
import org.osgi.framework.ServiceReference;
import org.osgi.framework.wiring.BundleRevision;
public class FilterImpl implements Filter
{
private final SimpleFilter m_filter;
public FilterImpl(String filterStr) throws InvalidSyntaxException
{
try
{
m_filter = SimpleFilter.parse(filterStr);
}
catch (Throwable th)
{
throw new InvalidSyntaxException(th.getMessage(), filterStr);
}
}
public boolean match(ServiceReference sr)
{
if (sr instanceof ServiceReferenceImpl)
{
return CapabilitySet.matches((ServiceReferenceImpl) sr, m_filter);
}
else
{
return CapabilitySet.matches(new WrapperCapability(sr), m_filter);
}
}
public boolean match(Dictionary<String, ? > dctnr)
{
return CapabilitySet.matches(new WrapperCapability(dctnr, false), m_filter);
}
public boolean matchCase(Dictionary<String, ? > dctnr)
{
return CapabilitySet.matches(new WrapperCapability(dctnr, true), m_filter);
}
public boolean matches(Map<String, ?> map)
{
return CapabilitySet.matches(new WrapperCapability(map), m_filter);
}
public boolean equals(Object o)
{
return toString().equals(o.toString());
}
public int hashCode()
{
return toString().hashCode();
}
public String toString()
{
return m_filter.toString();
}
static class WrapperCapability extends BundleCapabilityImpl
{
private final Map m_map;
public WrapperCapability(Map map)
{
super(null, null, Collections.EMPTY_MAP, Collections.EMPTY_MAP);
m_map = (map == null) ? Collections.EMPTY_MAP : map;
}
public WrapperCapability(Dictionary dict, boolean caseSensitive)
{
super(null, null, Collections.EMPTY_MAP, Collections.EMPTY_MAP);
m_map = new DictionaryToMap(dict, caseSensitive);
}
public WrapperCapability(ServiceReference sr)
{
super(null, null, Collections.EMPTY_MAP, Collections.EMPTY_MAP);
m_map = new StringMap();
for (String key : sr.getPropertyKeys())
{
m_map.put(key, sr.getProperty(key));
}
}
@Override
public BundleRevision getRevision()
{
throw new UnsupportedOperationException("Not supported yet.");
}
@Override
public String getNamespace()
{
throw new UnsupportedOperationException("Not supported yet.");
}
@Override
public Map<String, String> getDirectives()
{
throw new UnsupportedOperationException("Not supported yet.");
}
@Override
public Map<String, Object> getAttributes()
{
return m_map;
}
@Override
public List<String> getUses()
{
throw new UnsupportedOperationException("Not supported yet.");
}
}
private static class DictionaryToMap implements Map
{
private final Map m_map;
private final Dictionary m_dict;
public DictionaryToMap(Dictionary dict, boolean caseSensitive)
{
if (!caseSensitive)
{
m_dict = null;
m_map = new StringMap();
if (dict != null)
{
Enumeration keys = dict.keys();
while (keys.hasMoreElements())
{
Object key = keys.nextElement();
if (m_map.get(key) == null)
{
m_map.put(key, dict.get(key));
}
else
{
throw new IllegalArgumentException(
"Duplicate attribute: " + key.toString());
}
}
}
}
else
{
m_dict = dict;
m_map = null;
}
}
public int size()
{
throw new UnsupportedOperationException("Not supported yet.");
}
public boolean isEmpty()
{
throw new UnsupportedOperationException("Not supported yet.");
}
public boolean containsKey(Object o)
{
throw new UnsupportedOperationException("Not supported yet.");
}
public boolean containsValue(Object o)
{
throw new UnsupportedOperationException("Not supported yet.");
}
public Object get(Object o)
{
if (m_dict != null)
{
return m_dict.get(o);
}
else if (m_map != null)
{
return m_map.get(o);
}
return null;
}
public Object put(Object k, Object v)
{
throw new UnsupportedOperationException("Not supported yet.");
}
public Object remove(Object o)
{
throw new UnsupportedOperationException("Not supported yet.");
}
public void putAll(Map map)
{
throw new UnsupportedOperationException("Not supported yet.");
}
public void clear()
{
throw new UnsupportedOperationException("Not supported yet.");
}
public Set<Object> keySet()
{
throw new UnsupportedOperationException("Not supported yet.");
}
public Collection<Object> values()
{
throw new UnsupportedOperationException("Not supported yet.");
}
public Set<Entry<Object, Object>> entrySet()
{
return Collections.EMPTY_SET;
}
}
}