Find Usages Diff Raw Download HTML Widget
Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions 
1
   /*
2
    * Copyright (c) OSGi Alliance (2005, 2012). All Rights Reserved.
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
  
17
  package org.osgi.framework;
18
  
32
  import java.util.List;
33
  import java.util.Map;
34
  import java.util.Set;
Framework Utility class.

This class contains utility methods which access Framework functions that may be useful to bundles.

Version:
$Id: 1f46ea2bbbe2a1242fdaf0877709fb9c02eefae1 $
Since:
1.3
ThreadSafe:
47
  
48
  public class FrameworkUtil {
FrameworkUtil objects may not be constructed. 
51
  
52
  	private FrameworkUtil() {
53
  		// private empty constructor to prevent construction
54
  	}
Creates a Filter object. This Filter object may be used to match a ServiceReference object or a Dictionary object.

If the filter cannot be parsed, an InvalidSyntaxException will be thrown with a human readable message where the filter became unparsable.

This method returns a Filter implementation which may not perform as well as the framework implementation-specific Filter implementation returned by BundleContext.createFilter(java.lang.String).

Parameters:
filter The filter string.
Returns:
A Filter object encapsulating the filter string.
Throws:
InvalidSyntaxException If filter contains an invalid filter string that cannot be parsed.
java.lang.NullPointerException If filter is null.
See also:
Filter
77
  
78
  	public static Filter createFilter(String filter) throws InvalidSyntaxException {
79
  		return FilterImpl.newInstance(filter);
80
  	}
Match a Distinguished Name (DN) chain against a pattern. DNs can be matched using wildcards. A wildcard ('*' \u002A) replaces all possible values. Due to the structure of the DN, the comparison is more complicated than string-based wildcard matching.

A wildcard can stand for zero or more DNs in a chain, a number of relative distinguished names (RDNs) within a DN, or the value of a single RDN. The DNs in the chain and the matching pattern are canonicalized before processing. This means, among other things, that spaces must be ignored, except in values.

The format of a wildcard match pattern is: 

 matchPattern ::= dn-match ( ';' dn-match ) *
 dn-match     ::= ( '*' | rdn-match ) ( ',' rdn-match ) * | '-'
 rdn-match    ::= name '=' value-match
 value-match  ::= '*' | value-star
 value-star   ::= < value, requires escaped '*' and '-' >

The most simple case is a single wildcard; it must match any DN. A wildcard can also replace the first list of RDNs of a DN. The first RDNs are the least significant. Such lists of matched RDNs can be empty.

For example, a match pattern with a wildcard that matches all DNs that end with RDNs of o=ACME and c=US would look like this: 

 *, o=ACME, c=US
This match pattern would match the following DNs: 
 cn = Bugs Bunny, o = ACME, c = US
 ou = Carrots, cn=Daffy Duck, o=ACME, c=US
 street = 9C\, Avenue St. Drézéry, o=ACME, c=US
 dc=www, dc=acme, dc=com, o=ACME, c=US
 o=ACME, c=US
The following DNs would not match: 
 street = 9C\, Avenue St. Drézéry, o=ACME, c=FR
 dc=www, dc=acme, dc=com, c=US
If a wildcard is used for a value of an RDN, the value must be exactly *. The wildcard must match any value, and no substring matching must be done. For example: 
 cn=*,o=ACME,c=*
This match pattern with wildcard must match the following DNs: 
 cn=Bugs Bunny,o=ACME,c=US
 cn = Daffy Duck , o = ACME , c = US
 cn=Road Runner, o=ACME, c=NL
But not: 
 o=ACME, c=NL
 dc=acme.com, cn=Bugs Bunny, o=ACME, c=US

A match pattern may contain a chain of DN match patterns. The semicolon( ';' \u003B) must be used to separate DN match patterns in a chain. Wildcards can also be used to match against a complete DN within a chain.

The following example matches a certificate signed by Tweety Inc. in the US. 

 * ; ou=S & V, o=Tweety Inc., c=US

The wildcard ('*') matches zero or one DN in the chain, however, sometimes it is necessary to match a longer chain. The minus sign ( '-' \u002D) represents zero or more DNs, whereas the asterisk only represents a single DN. For example, to match a DN where the Tweety Inc. is in the DN chain, use the following expression: 

 - ; *, o=Tweety Inc., c=US

Parameters:
matchPattern The pattern against which to match the DN chain.
dnChain The DN chain to match against the specified pattern. Each element of the chain must be of type String and use the format defined in RFC 2253.
Returns:
true If the pattern matches the DN chain; otherwise false is returned.
Throws:
java.lang.IllegalArgumentException If the specified match pattern or DN chain is invalid.
Since:
1.5
190
 
191
 	public static boolean matchDistinguishedNameChain(String matchPattern, List<String> dnChain) {
192
 		return DNChainMatching.match(matchPattern, dnChain);
193
 	}
Return a Bundle for the specified bundle class. The returned Bundle is the bundle associated with the bundle class loader which defined the specified class.

Parameters:
classFromBundle A class defined by a bundle class loader.
Returns:
A Bundle for the specified bundle class or null if the specified class was not defined by a bundle class loader.
Since:
1.5
204
 
205
 	public static Bundle getBundle(final Class<?> classFromBundle) {
206
 		// We use doPriv since the caller may not have permission
207
 		// to call getClassLoader.
208
 		Object cl = AccessController.doPrivileged(new PrivilegedAction<Object>() {
209
 			public Object run() {
210
 				return classFromBundle.getClassLoader();
211
 			}
212
 		});
213
 
214
 		if (cl instanceof BundleReference) {
215
 			return ((BundleReference) cl).getBundle();
216
 		}
217
 		return null;
218
 	}
RFC 1960-based Filter. Filter objects can be created by calling the constructor with the desired filter string. A Filter object can be called numerous times to determine if the match argument matches the filter string that was used to create the Filter object.

The syntax of a filter string is the string representation of LDAP search filters as defined in RFC 1960: A String Representation of LDAP Search Filters (available at http://www.ietf.org/rfc/rfc1960.txt). It should be noted that RFC 2254: A String Representation of LDAP Search Filters (available at http://www.ietf.org/rfc/rfc2254.txt) supersedes RFC 1960 but only adds extensible matching and is not applicable for this API.

The string representation of an LDAP search filter is defined by the following grammar. It uses a prefix format. 

   <filter> ::= '(' <filtercomp> ')'
   <filtercomp> ::= <and> | <or> | <not> | <item>
   <and> ::= '&' <filterlist>
   <or> ::= '|' <filterlist>
   <not> ::= '!' <filter>
   <filterlist> ::= <filter> | <filter> <filterlist>
   <item> ::= <simple> | <present> | <substring>
   <simple> ::= <attr> <filtertype> <value>
   <filtertype> ::= <equal> | <approx> | <greater> | <less>
   <equal> ::= '='
   <approx> ::= '˜='
   <greater> ::= '>='
   <less> ::= '<='
   <present> ::= <attr> '=*'
   <substring> ::= <attr> '=' <initial> <any> <final>
   <initial> ::= NULL | <value>
   <any> ::= '*' <starval>
   <starval> ::= NULL | <value> '*' <starval>
   <final> ::= NULL | <value>
&lt;attr&gt; is a string representing an attribute, or key, in the properties objects of the registered services. Attribute names are not case sensitive; that is cn and CN both refer to the same attribute. &lt;value&gt; is a string representing the value, or part of one, of a key in the properties objects of the registered services. If a &lt;value&gt; must contain one of the characters ' *' or '(' or ')', these characters should be escaped by preceding them with the backslash '\' character. Note that although both the &lt;substring&gt; and &lt;present&gt; productions can produce the 'attr=*' construct, this construct is used only to denote a presence filter.

Examples of LDAP filters are: 

   "(cn=Babs Jensen)"
   "(!(cn=Tim Howes))"
   "(&(" + Constants.OBJECTCLASS + "=Person)(|(sn=Jensen)(cn=Babs J*)))"
   "(o=univ*of*mich*)"

The approximate match (~=) is implementation specific but should at least ignore case and white space differences. Optional are codes like soundex or other smart "closeness" comparisons.

Comparison of values is not straightforward. Strings are compared differently than numbers and it is possible for a key to have multiple values. Note that that keys in the match argument must always be strings. The comparison is defined by the object type of the key's value. The following rules apply for comparison:

Property Value Type Comparison Type
StringString comparison
Integer, Long, Float, Double, Byte, Short, BigInteger, BigDecimalnumerical comparison
Charactercharacter comparison
Booleanequality comparisons only
[] (array)recursively applied to values
Collectionrecursively applied to values
Note: arrays of primitives are also supported.
A filter matches a key that has multiple values if it matches at least one of those values. For example, 
 Dictionary d = new Hashtable();
 d.put("cn", new String[] {"a", "b", "c"});
d will match (cn=a) and also (cn=b)

A filter component that references a key having an unrecognizable data type will evaluate to false . 

341
 
342
 	static private final class FilterImpl implements Filter {
343
 		/* filter operators */
344
 		private static final int	EQUAL		= 1;
345
 		private static final int	APPROX		= 2;
346
 		private static final int	GREATER		= 3;
347
 		private static final int	LESS		= 4;
348
 		private static final int	PRESENT		= 5;
349
 		private static final int	SUBSTRING	= 6;
350
 		private static final int	AND			= 7;
351
 		private static final int	OR			= 8;
352
 		private static final int	NOT			= 9;
filter operation
354
 
355
 		private final int			op;
filter attribute or null if operation AND, OR or NOT
356
 
357
 		private final String		attr;
filter operands
358
 
359
 		private final Object		value;
360
 
361
 		/* normalized filter string for Filter object */
362
 		private transient String	filterString;
Constructs a FrameworkUtil.FilterImpl object. This filter object may be used to match a ServiceReference or a Dictionary.

If the filter cannot be parsed, an InvalidSyntaxException will be thrown with a human readable message where the filter became unparsable.

Parameters:
filterString the filter string.
Throws:
InvalidSyntaxException If the filter parameter contains an invalid filter string that cannot be parsed.
376
 
377
 		static FilterImpl newInstance(String filterString) throws InvalidSyntaxException {
378
 			return new Parser(filterString).parse();
379
 		}
380
 
381
 		FilterImpl(int operation, String attr, Object value) {
382
 			this. = operation;
383
 			this. = attr;
384
 			this. = value;
385
 			 = null;
386
 		}
Filter using a service's properties.

This Filter is executed using the keys and values of the referenced service's properties. The keys are looked up in a case insensitive manner.

Parameters:
reference The reference to the service whose properties are used in the match.
Returns:
true if the service's properties match this Filter; false otherwise.
399
 
400
 		public boolean match(ServiceReference<?> reference) {
401
 			return matches(new ServiceReferenceMap(reference));
402
 		}
Filter using a Dictionary with case insensitive key lookup. This Filter is executed using the specified Dictionary's keys and values. The keys are looked up in a case insensitive manner.

Parameters:
dictionary The Dictionary whose key/value pairs are used in the match.
Returns:
true if the Dictionary's values match this filter; false otherwise.
Throws:
java.lang.IllegalArgumentException If dictionary contains case variants of the same key name.
416
 
417
 		public boolean match(Dictionary<String, ?> dictionary) {
418
 			return matches(new CaseInsensitiveMap(dictionary));
419
 		}
Filter using a Dictionary. This Filter is executed using the specified Dictionary's keys and values. The keys are looked up in a normal manner respecting case.

Parameters:
dictionary The Dictionary whose key/value pairs are used in the match.
Returns:
true if the Dictionary's values match this filter; false otherwise.
Since:
1.3
431
 
432
 		public boolean matchCase(Dictionary<String, ?> dictionary) {
433
 			switch () {
434
 				case  : {
435
 					FilterImpl[] filters = (FilterImpl[]) ;
436
 					for (FilterImpl f : filters) {
437
 						if (!f.matchCase(dictionary)) {
438
 							return false;
439
 						}
440
 					}
441
 					return true;
442
 				}
443
 
444
 				case  : {
445
 					FilterImpl[] filters = (FilterImpl[]) ;
446
 					for (FilterImpl f : filters) {
447
 						if (f.matchCase(dictionary)) {
448
 							return true;
449
 						}
450
 					}
451
 					return false;
452
 				}
453
 
454
 				case  : {
455
 					FilterImpl filter = (FilterImpl) ;
456
 					return !filter.matchCase(dictionary);
457
 				}
458
 
459
 				case  :
460
 				case  :
461
 				case  :
462
 				case  :
463
 				case  : {
464
 					Object prop = (dictionary == null) ? null : dictionary.get();
465
 					return compare(, prop, );
466
 				}
467
 
468
 				case  : {
469
 					Object prop = (dictionary == null) ? null : dictionary.get();
470
 					return prop != null;
471
 				}
472
 			}
473
 
474
 			return false;
475
 		}
Filter using a Map. This Filter is executed using the specified Map's keys and values. The keys are looked up in a normal manner respecting case.

Parameters:
map The Map whose key/value pairs are used in the match. Maps with null key or values are not supported. A null value is considered not present to the filter.
Returns:
true if the Map's values match this filter; false otherwise.
Since:
1.6
488
 
489
 		public boolean matches(Map<String, ?> map) {
490
 			switch () {
491
 				case  : {
492
 					FilterImpl[] filters = (FilterImpl[]) ;
493
 					for (FilterImpl f : filters) {
494
 						if (!f.matches(map)) {
495
 							return false;
496
 						}
497
 					}
498
 					return true;
499
 				}
500
 
501
 				case  : {
502
 					FilterImpl[] filters = (FilterImpl[]) ;
503
 					for (FilterImpl f : filters) {
504
 						if (f.matches(map)) {
505
 							return true;
506
 						}
507
 					}
508
 					return false;
509
 				}
510
 
511
 				case  : {
512
 					FilterImpl filter = (FilterImpl) ;
513
 					return !filter.matches(map);
514
 				}
515
 
516
 				case  :
517
 				case  :
518
 				case  :
519
 				case  :
520
 				case  : {
521
 					Object prop = (map == null) ? null : map.get();
522
 					return compare(, prop, );
523
 				}
524
 
525
 				case  : {
526
 					Object prop = (map == null) ? null : map.get();
527
 					return prop != null;
528
 				}
529
 			}
530
 
531
 			return false;
532
 		}
Returns this Filter's filter string.

The filter string is normalized by removing whitespace which does not affect the meaning of the filter.

Returns:
This Filter's filter string.
541
 
542
 		public String toString() {
543
 			String result = ;
544
 			if (result == null) {
545
 				 = result = normalize().toString();
546
 			}
547
 			return result;
548
 		}
Returns this Filter's normalized filter string.

The filter string is normalized by removing whitespace which does not affect the meaning of the filter.

Returns:
This Filter's filter string.
557
 
558
 		private StringBuffer normalize() {
559
 			StringBuffer sb = new StringBuffer();
560
 			sb.append('(');
561
 
562
 			switch () {
563
 				case  : {
564
 					sb.append('&');
565
 
566
 					FilterImpl[] filters = (FilterImpl[]) ;
567
 					for (FilterImpl f : filters) {
568
 						sb.append(f.normalize());
569
 					}
570
 
571
 					break;
572
 				}
573
 
574
 				case  : {
575
 					sb.append('|');
576
 
577
 					FilterImpl[] filters = (FilterImpl[]) ;
578
 					for (FilterImpl f : filters) {
579
 						sb.append(f.normalize());
580
 					}
581
 
582
 					break;
583
 				}
584
 
585
 				case  : {
586
 					sb.append('!');
587
 					FilterImpl filter = (FilterImpl) ;
588
 					sb.append(filter.normalize());
589
 
590
 					break;
591
 				}
592
 
593
 				case  : {
594
 					sb.append();
595
 					sb.append('=');
596
 
597
 					String[] substrings = (String[]) ;
598
 
599
 					for (String substr : substrings) {
600
 						if (substr == null) /* * */{
601
 							sb.append('*');
602
 						} else /* xxx */{
603
 							sb.append(encodeValue(substr));
604
 						}
605
 					}
606
 
607
 					break;
608
 				}
609
 				case  : {
610
 					sb.append();
611
 					sb.append('=');
613
 
614
 					break;
615
 				}
616
 				case  : {
617
 					sb.append();
618
 					sb.append(">=");
620
 
621
 					break;
622
 				}
623
 				case  : {
624
 					sb.append();
625
 					sb.append("<=");
627
 
628
 					break;
629
 				}
630
 				case  : {
631
 					sb.append();
632
 					sb.append("~=");
634
 
635
 					break;
636
 				}
637
 
638
 				case  : {
639
 					sb.append();
640
 					sb.append("=*");
641
 
642
 					break;
643
 				}
644
 			}
645
 
646
 			sb.append(')');
647
 
648
 			return sb;
649
 		}
Compares this Filter to another Filter.

This implementation returns the result of calling this.toString().equals(obj.toString().

Parameters:
obj The object to compare against this Filter.
Returns:
If the other object is a Filter object, then returns the result of calling this.toString().equals(obj.toString(); false otherwise.
663
 
664
 		public boolean equals(Object obj) {
665
 			if (obj == this) {
666
 				return true;
667
 			}
668
 
669
 			if (!(obj instanceof Filter)) {
670
 				return false;
671
 			}
672
 
673
 			return this.toString().equals(obj.toString());
674
 		}
Returns the hashCode for this Filter.

This implementation returns the result of calling this.toString().hashCode().

Returns:
The hashCode of this Filter.
684
 
685
 		public int hashCode() {
686
 			return this.toString().hashCode();
687
 		}
Encode the value string such that '(', '*', ')' and '\' are escaped.

Parameters:
value unencoded value string.
Returns:
encoded value string.
694
 
695
 		private static String encodeValue(String value) {
696
 			boolean encoded = false;
697
 			int inlen = value.length();
698
 			int outlen = inlen << 1; /* inlen 2 */
699
 
700
 			char[] output = new char[outlen];
701
 			value.getChars(0, inlen, output, inlen);
702
 
703
 			int cursor = 0;
704
 			for (int i = inlen; i < outlen; i++) {
705
 				char c = output[i];
706
 
707
 				switch (c) {
708
 					case '(' :
709
 					case '*' :
710
 					case ')' :
711
 					case '\\' : {
712
 						output[cursor] = '\\';
713
 						cursor++;
714
 						encoded = true;
715
 
716
 						break;
717
 					}
718
 				}
719
 
720
 				output[cursor] = c;
721
 				cursor++;
722
 			}
723
 
724
 			return encoded ? new String(output, 0, cursor) : value;
725
 		}
726
 
727
 		private boolean compare(int operation, Object value1, Object value2) {
728
 			if (value1 == null) {
729
 				return false;
730
 			}
731
 			if (value1 instanceof String) {
732
 				return compare_String(operation, (String) value1, value2);
733
 			}
734
 
735
 			Class<?> clazz = value1.getClass();
736
 			if (clazz.isArray()) {
737
 				Class<?> type = clazz.getComponentType();
738
 				if (type.isPrimitive()) {
739
 					return compare_PrimitiveArray(operation, type, value1, value2);
740
 				}
741
 				return compare_ObjectArray(operation, (Object[]) value1, value2);
742
 			}
743
 			if (value1 instanceof Collection<?>) {
744
 				return compare_Collection(operation, (Collection<?>) value1, value2);
745
 			}
746
 			if (value1 instanceof Integer) {
747
 				return compare_Integer(operation, ((Integer) value1).intValue(), value2);
748
 			}
749
 			if (value1 instanceof Long) {
750
 				return compare_Long(operation, ((Long) value1).longValue(), value2);
751
 			}
752
 			if (value1 instanceof Byte) {
753
 				return compare_Byte(operation, ((Byte) value1).byteValue(), value2);
754
 			}
755
 			if (value1 instanceof Short) {
756
 				return compare_Short(operation, ((Short) value1).shortValue(), value2);
757
 			}
758
 			if (value1 instanceof Character) {
759
 				return compare_Character(operation, ((Character) value1).charValue(), value2);
760
 			}
761
 			if (value1 instanceof Float) {
762
 				return compare_Float(operation, ((Float) value1).floatValue(), value2);
763
 			}
764
 			if (value1 instanceof Double) {
765
 				return compare_Double(operation, ((Double) value1).doubleValue(), value2);
766
 			}
767
 			if (value1 instanceof Boolean) {
768
 				return compare_Boolean(operation, ((Boolean) value1).booleanValue(), value2);
769
 			}
770
 			if (value1 instanceof Comparable<?>) {
771
 				Comparable<Object> comparable = (Comparable<Object>) value1;
772
 				return compare_Comparable(operation, comparable, value2);
773
 			}
774
 			return compare_Unknown(operation, value1, value2);
775
 		}
776
 
777
 		private boolean compare_Collection(int operation, Collection<?> collection, Object value2) {
778
 			for (Object value1 : collection) {
779
 				if (compare(operation, value1, value2)) {
780
 					return true;
781
 				}
782
 			}
783
 			return false;
784
 		}
785
 
786
 		private boolean compare_ObjectArray(int operation, Object[] array, Object value2) {
787
 			for (Object value1 : array) {
788
 				if (compare(operation, value1, value2)) {
789
 					return true;
790
 				}
791
 			}
792
 			return false;
793
 		}
794
 
795
 		private boolean compare_PrimitiveArray(int operation, Class<?> type, Object primarray, Object value2) {
796
 			if (..isAssignableFrom(type)) {
797
 				int[] array = (int[]) primarray;
798
 				for (int value1 : array) {
799
 					if (compare_Integer(operation, value1, value2)) {
800
 						return true;
801
 					}
802
 				}
803
 				return false;
804
 			}
805
 			if (..isAssignableFrom(type)) {
806
 				long[] array = (long[]) primarray;
807
 				for (long value1 : array) {
808
 					if (compare_Long(operation, value1, value2)) {
809
 						return true;
810
 					}
811
 				}
812
 				return false;
813
 			}
814
 			if (..isAssignableFrom(type)) {
815
 				byte[] array = (byte[]) primarray;
816
 				for (byte value1 : array) {
817
 					if (compare_Byte(operation, value1, value2)) {
818
 						return true;
819
 					}
820
 				}
821
 				return false;
822
 			}
823
 			if (..isAssignableFrom(type)) {
824
 				short[] array = (short[]) primarray;
825
 				for (short value1 : array) {
826
 					if (compare_Short(operation, value1, value2)) {
827
 						return true;
828
 					}
829
 				}
830
 				return false;
831
 			}
833
 				char[] array = (char[]) primarray;
834
 				for (char value1 : array) {
835
 					if (compare_Character(operation, value1, value2)) {
836
 						return true;
837
 					}
838
 				}
839
 				return false;
840
 			}
841
 			if (..isAssignableFrom(type)) {
842
 				float[] array = (float[]) primarray;
843
 				for (float value1 : array) {
844
 					if (compare_Float(operation, value1, value2)) {
845
 						return true;
846
 					}
847
 				}
848
 				return false;
849
 			}
850
 			if (..isAssignableFrom(type)) {
851
 				double[] array = (double[]) primarray;
852
 				for (double value1 : array) {
853
 					if (compare_Double(operation, value1, value2)) {
854
 						return true;
855
 					}
856
 				}
857
 				return false;
858
 			}
859
 			if (..isAssignableFrom(type)) {
860
 				boolean[] array = (boolean[]) primarray;
861
 				for (boolean value1 : array) {
862
 					if (compare_Boolean(operation, value1, value2)) {
863
 						return true;
864
 					}
865
 				}
866
 				return false;
867
 			}
868
 			return false;
869
 		}
870
 
871
 		private boolean compare_String(int operation, String string, Object value2) {
872
 			switch (operation) {
873
 				case  : {
874
 					String[] substrings = (String[]) value2;
875
 					int pos = 0;
876
 					for (int i = 0, size = substrings.length; i < size; i++) {
877
 						String substr = substrings[i];
878
 
879
 						if (i + 1 < size) /* if this is not that last substr */{
880
 							if (substr == null) /* * */{
881
 								String substr2 = substrings[i + 1];
882
 
883
 								if (substr2 == null) /* ** */
884
 									continue; /* ignore first star */
885
 								/* xxx */
886
 								int index = string.indexOf(substr2, pos);
887
 								if (index == -1) {
888
 									return false;
889
 								}
890
 
891
 								pos = index + substr2.length();
892
 								if (i + 2 < size) // if there are more
893
 									// substrings, increment
894
 									// over the string we just
895
 									// matched; otherwise need
896
 									// to do the last substr
897
 									// check
898
 									i++;
899
 							} else /* xxx */{
900
 								int len = substr.length();
901
 								if (string.regionMatches(pos, substr, 0, len)) {
902
 									pos += len;
903
 								} else {
904
 									return false;
905
 								}
906
 							}
907
 						} else /* last substr */{
908
 							if (substr == null) /* * */{
909
 								return true;
910
 							}
911
 							/* xxx */
912
 							return string.endsWith(substr);
913
 						}
914
 					}
915
 
916
 					return true;
917
 				}
918
 				case  : {
919
 					return string.equals(value2);
920
 				}
921
 				case  : {
922
 					string = approxString(string);
923
 					String string2 = approxString((String) value2);
924
 
925
 					return string.equalsIgnoreCase(string2);
926
 				}
927
 				case  : {
928
 					return string.compareTo((String) value2) >= 0;
929
 				}
930
 				case  : {
931
 					return string.compareTo((String) value2) <= 0;
932
 				}
933
 			}
934
 			return false;
935
 		}
936
 
937
 		private boolean compare_Integer(int operation, int intval, Object value2) {
938
 			if (operation == ) {
939
 				return false;
940
 			}
941
 			int intval2;
942
 			try {
943
 				intval2 = Integer.parseInt(((String) value2).trim());
944
 			} catch (IllegalArgumentException e) {
945
 				return false;
946
 			}
947
 			switch (operation) {
948
 				case  :
949
 				case  : {
950
 					return intval == intval2;
951
 				}
952
 				case  : {
953
 					return intval >= intval2;
954
 				}
955
 				case  : {
956
 					return intval <= intval2;
957
 				}
958
 			}
959
 			return false;
960
 		}
961
 
962
 		private boolean compare_Long(int operation, long longval, Object value2) {
963
 			if (operation == ) {
964
 				return false;
965
 			}
966
 			long longval2;
967
 			try {
968
 				longval2 = Long.parseLong(((String) value2).trim());
969
 			} catch (IllegalArgumentException e) {
970
 				return false;
971
 			}
972
 
973
 			switch (operation) {
974
 				case  :
975
 				case  : {
976
 					return longval == longval2;
977
 				}
978
 				case  : {
979
 					return longval >= longval2;
980
 				}
981
 				case  : {
982
 					return longval <= longval2;
983
 				}
984
 			}
985
 			return false;
986
 		}
987
 
988
 		private boolean compare_Byte(int operation, byte byteval, Object value2) {
989
 			if (operation == ) {
990
 				return false;
991
 			}
992
 			byte byteval2;
993
 			try {
994
 				byteval2 = Byte.parseByte(((String) value2).trim());
995
 			} catch (IllegalArgumentException e) {
996
 				return false;
997
 			}
998
 
999
 			switch (operation) {
1000
				case  :
1001
				case  : {
1002
					return byteval == byteval2;
1004
				case  : {
1005
					return byteval >= byteval2;
1007
				case  : {
1008
					return byteval <= byteval2;
1011
			return false;
1014
		private boolean compare_Short(int operation, short shortval, Object value2) {
1015
			if (operation == ) {
1016
				return false;
1018
			short shortval2;
1019
			try {
1020
				shortval2 = Short.parseShort(((String) value2).trim());
1021
			} catch (IllegalArgumentException e) {
1022
				return false;
1025
			switch (operation) {
1026
				case  :
1027
				case  : {
1028
					return shortval == shortval2;
1030
				case  : {
1031
					return shortval >= shortval2;
1033
				case  : {
1034
					return shortval <= shortval2;
1037
			return false;
1040
		private boolean compare_Character(int operation, char charval, Object value2) {
1041
			if (operation == ) {
1042
				return false;
1044
			char charval2;
1045
			try {
1046
				charval2 = ((String) value2).charAt(0);
1048
				return false;
1051
			switch (operation) {
1052
				case  : {
1053
					return charval == charval2;
1055
				case  : {
1056
					return (charval == charval2) || (Character.toUpperCase(charval) == Character.toUpperCase(charval2)) || (Character.toLowerCase(charval) == Character.toLowerCase(charval2));
1058
				case  : {
1059
					return charval >= charval2;
1061
				case  : {
1062
					return charval <= charval2;
1065
			return false;
1068
		private boolean compare_Boolean(int operation, boolean boolval, Object value2) {
1069
			if (operation == ) {
1070
				return false;
1072
			boolean boolval2 = Boolean.valueOf(((String) value2).trim()).booleanValue();
1073
			switch (operation) {
1074
				case  :
1075
				case  :
1076
				case  :
1077
				case  : {
1078
					return boolval == boolval2;
1081
			return false;
1084
		private boolean compare_Float(int operation, float floatval, Object value2) {
1085
			if (operation == ) {
1086
				return false;
1088
			float floatval2;
1089
			try {
1090
				floatval2 = Float.parseFloat(((String) value2).trim());
1091
			} catch (IllegalArgumentException e) {
1092
				return false;
1095
			switch (operation) {
1096
				case  :
1097
				case  : {
1098
					return Float.compare(floatval, floatval2) == 0;
1100
				case  : {
1101
					return Float.compare(floatval, floatval2) >= 0;
1103
				case  : {
1104
					return Float.compare(floatval, floatval2) <= 0;
1107
			return false;
1110
		private boolean compare_Double(int operation, double doubleval, Object value2) {
1111
			if (operation == ) {
1112
				return false;
1114
			double doubleval2;
1115
			try {
1116
				doubleval2 = Double.parseDouble(((String) value2).trim());
1117
			} catch (IllegalArgumentException e) {
1118
				return false;
1121
			switch (operation) {
1122
				case  :
1123
				case  : {
1124
					return Double.compare(doubleval, doubleval2) == 0;
1126
				case  : {
1127
					return Double.compare(doubleval, doubleval2) >= 0;
1129
				case  : {
1130
					return Double.compare(doubleval, doubleval2) <= 0;
1133
			return false;
1136
		private static Object valueOf(Class<?> target, String value2) {
1137
			do {
1138
				Method method;
1139
				try {
1140
					method = target.getMethod("valueOf", String.class);
1141
				} catch (NoSuchMethodException e) {
1142
					break;
1144
				if (Modifier.isStatic(method.getModifiers()) && target.isAssignableFrom(method.getReturnType())) {
1146
					try {
1147
						return method.invoke(null, value2.trim());
1148
					} catch (IllegalAccessException e) {
1149
						return null;
1151
						return null;
1154
			} while (false);
1156
			do {
1157
				Constructor<?> constructor;
1158
				try {
1159
					constructor = target.getConstructor(String.class);
1160
				} catch (NoSuchMethodException e) {
1161
					break;
1163
				setAccessible(constructor);
1164
				try {
1165
					return constructor.newInstance(value2.trim());
1166
				} catch (IllegalAccessException e) {
1167
					return null;
1169
					return null;
1170
				} catch (InstantiationException e) {
1171
					return null;
1173
			} while (false);
1175
			return null;
1178
		private static void setAccessible(AccessibleObject accessible) {
1179
			if (!accessible.isAccessible()) {
1180
				AccessController.doPrivileged(new SetAccessibleAction(accessible));
1184
		private boolean compare_Comparable(int operation, Comparable<Object> value1, Object value2) {
1185
			if (operation == ) {
1186
				return false;
1188
			value2 = valueOf(value1.getClass(), (String) value2);
1189
			if (value2 == null) {
1190
				return false;
1192
			try {
1193
				switch (operation) {
1194
					case  :
1195
					case  : {
1196
						return value1.compareTo(value2) == 0;
1198
					case  : {
1199
						return value1.compareTo(value2) >= 0;
1201
					case  : {
1202
						return value1.compareTo(value2) <= 0;
1205
			} catch (Exception e) {
1206
				// if the compareTo method throws an exception; return false
1207
				return false;
1209
			return false;
1212
		private boolean compare_Unknown(int operation, Object value1, Object value2) {
1213
			if (operation == ) {
1214
				return false;
1216
			value2 = valueOf(value1.getClass(), (String) value2);
1217
			if (value2 == null) {
1218
				return false;
1220
			try {
1221
				switch (operation) {
1222
					case  :
1223
					case  :
1224
					case  :
1225
					case  : {
1226
						return value1.equals(value2);
1229
			} catch (Exception e) {
1230
				// if the equals method throws an exception; return false
1231
				return false;
1233
			return false;
1234
		}
Map a string for an APPROX (~=) comparison. This implementation removes white spaces. This is the minimum implementation allowed by the OSGi spec.

Parameters:
input Input string.
Returns:
String ready for APPROX comparison.
1245
		private static String approxString(String input) {
1246
			boolean changed = false;
1247
			char[] output = input.toCharArray();
1248
			int cursor = 0;
1249
			for (char c : output) {
1250
				if (Character.isWhitespace(c)) {
1251
					changed = true;
1252
					continue;
1255
				output[cursor] = c;
1256
				cursor++;
1259
			return changed ? new String(output, 0, cursor) : input;
1260
		}
Parser class for OSGi filter strings. This class parses the complete filter string and builds a tree of Filter objects rooted at the parent. 
1267
		static private final class Parser {
1268
			private final String	filterstring;
1269
			private final char[]	filterChars;
1270
			private int				pos;
1272
			Parser(String filterstring) {
1273
				this. = filterstring;
1274
				 = filterstring.toCharArray();
1275
				 = 0;
1279
				FilterImpl filter;
1280
				try {
1281
					filter = parse_filter();
1283
					throw new InvalidSyntaxException("Filter ended abruptly", , e);
1286
				if ( != .) {
1287
					throw new InvalidSyntaxException("Extraneous trailing characters: " + .substring(), );
1289
				return filter;
1293
				FilterImpl filter;
1296
				if ([] != '(') {
1297
					throw new InvalidSyntaxException("Missing '(': " + .substring(), );
1302
				filter = parse_filtercomp();
1306
				if ([] != ')') {
1307
					throw new InvalidSyntaxException("Missing ')': " + .substring(), );
1314
				return filter;
1320
				char c = [];
1322
				switch (c) {
1323
					case '&' : {
1325
						return parse_and();
1327
					case '|' : {
1329
						return parse_or();
1331
					case '!' : {
1333
						return parse_not();
1336
				return parse_item();
1340
				int lookahead = ;
1343
				if ([] != '(') {
1344
					 = lookahead - 1;
1345
					return parse_item();
1348
				List<FilterImpl> operands = new ArrayList<FilterImpl>(10);
1350
				while ([] == '(') {
1352
					operands.add(child);
1355
				return new FilterImpl(., null, operands.toArray(new FilterImpl[operands.size()]));
1359
				int lookahead = ;
1362
				if ([] != '(') {
1363
					 = lookahead - 1;
1364
					return parse_item();
1367
				List<FilterImpl> operands = new ArrayList<FilterImpl>(10);
1369
				while ([] == '(') {
1371
					operands.add(child);
1374
				return new FilterImpl(., null, operands.toArray(new FilterImpl[operands.size()]));
1378
				int lookahead = ;
1381
				if ([] != '(') {
1382
					 = lookahead - 1;
1383
					return parse_item();
1388
				return new FilterImpl(., null, child);
1392
				String attr = parse_attr();
1396
				switch ([]) {
1397
					case '~' : {
1398
						if ([ + 1] == '=') {
1399
							 += 2;
1400
							return new FilterImpl(., attr, parse_value());
1402
						break;
1404
					case '>' : {
1405
						if ([ + 1] == '=') {
1406
							 += 2;
1407
							return new FilterImpl(., attr, parse_value());
1409
						break;
1411
					case '<' : {
1412
						if ([ + 1] == '=') {
1413
							 += 2;
1414
							return new FilterImpl(., attr, parse_value());
1416
						break;
1418
					case '=' : {
1419
						if ([ + 1] == '*') {
1420
							int oldpos = ;
1421
							 += 2;
1423
							if ([] == ')') {
1424
								return new FilterImpl(., attr, null);
1426
							 = oldpos;
1430
						Object string = parse_substring();
1432
						if (string instanceof String) {
1433
							return new FilterImpl(., attr, string);
1435
						return new FilterImpl(., attr, string);
1439
				throw new InvalidSyntaxException("Invalid operator: " + .substring(), );
1445
				int begin = ;
1446
				int end = ;
1448
				char c = [];
1450
				while (c != '~' && c != '<' && c != '>' && c != '=' && c != '(' && c != ')') {
1453
					if (!Character.isWhitespace(c)) {
1454
						end = ;
1460
				int length = end - begin;
1462
				if (length == 0) {
1463
					throw new InvalidSyntaxException("Missing attr: " + .substring(), );
1466
				return new String(, begin, length);
1472
				parseloop: while (true) {
1473
					char c = [];
1475
					switch (c) {
1476
						case ')' : {
1477
							break parseloop;
1480
						case '(' : {
1481
							throw new InvalidSyntaxException("Invalid value: " + .substring(), );
1484
						case '\\' : {
1487
							/* fall through into default */
1490
						default : {
1491
							sb.append(c);
1493
							break;
1498
				if (sb.length() == 0) {
1499
					throw new InvalidSyntaxException("Missing value: " + .substring(), );
1502
				return sb.toString();