1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
|
/*
* $Header: /cvshome/build/org.osgi.framework/src/org/osgi/framework/FrameworkUtil.java,v 1.10 2007/02/21 16:49:05 hargrave Exp $
*
* Copyright (c) OSGi Alliance (2005, 2007). All Rights Reserved.
*
* Licensed 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.osgi.framework;
import java.lang.reflect.*;
import java.security.AccessController;
import java.security.PrivilegedAction;
/**
* Framework Utility class.
*
* <p>
* This class contains utility methods which access Framework functions that may
* be useful to bundles.
*
* @since 1.3
* @ThreadSafe
* @version $Revision: 1.10 $
*/
public class FrameworkUtil {
/*
* NOTE: A framework implementor may also choose to replace this class in
* their distribution with a class that directly interfaces with the
* framework implementation.
*/
/*
* This class will load the FrameworkUtil class in the package named by the
* org.osgi.vendor.framework package. For each instance of this class, an
* instance of the vendor FrameworkUtil class will be created and this class
* will delegate method calls to the vendor FrameworkUtil instance.
*/
private static class ImplHolder implements PrivilegedAction<Method> {
private static final String packageProperty = "org.osgi.vendor.framework";
/*
* This is the delegate method used by createFilter.
*/
static final Method createFilter;
static {
createFilter = AccessController.doPrivileged(new ImplHolder());
}
private ImplHolder() {
}
public Method run() {
String packageName = System
.getProperty(packageProperty);
if (packageName == null) {
throw new NoClassDefFoundError(packageProperty
+ " property not set");
}
Class<?> delegateClass;
try {
delegateClass = Class.forName(packageName
+ ".FrameworkUtil");
}
catch (ClassNotFoundException e) {
throw new NoClassDefFoundError(e.toString());
}
Method result;
try {
result = delegateClass.getMethod("createFilter",
new Class[] {String.class});
}
catch (NoSuchMethodException e) {
throw new NoSuchMethodError(e.toString());
}
if (!Modifier.isStatic(result.getModifiers())) {
throw new NoSuchMethodError(
"createFilter method must be static");
}
return result;
}
}
/**
* FrameworkUtil objects may not be constructed.
*/
private FrameworkUtil() {}
/**
* Creates a <code>Filter</code> object. This <code>Filter</code> object
* may be used to match a <code>ServiceReference</code> object or a
* <code>Dictionary</code> object.
*
* <p>
* If the filter cannot be parsed, an {@link InvalidSyntaxException} will be
* thrown with a human readable message where the filter became unparsable.
*
* @param filter The filter string.
* @return A <code>Filter</code> object encapsulating the filter string.
* @throws InvalidSyntaxException If <code>filter</code> contains an
* invalid filter string that cannot be parsed.
* @throws NullPointerException If <code>filter</code> is null.
*
* @see Filter
*/
public static Filter createFilter(String filter)
throws InvalidSyntaxException {
try {
try {
return (Filter) ImplHolder.createFilter
.invoke(null, new Object[] {filter});
}
catch (InvocationTargetException e) {
throw e.getTargetException();
}
}
catch (InvalidSyntaxException e) {
throw e;
}
catch (Error e) {
throw e;
}
catch (RuntimeException e) {
throw e;
}
catch (Throwable e) {
throw new RuntimeException(e.toString());
}
}
}
|
