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
|
/*
* Copyright (c) OSGi Alliance (2004, 2013). 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.service.condpermadmin;
import java.util.Dictionary;
import org.osgi.annotation.versioning.ConsumerType;
/**
* The interface implemented by a Condition. Conditions are bound to Permissions
* using Conditional Permission Info. The Permissions of a ConditionalPermission
* Info can only be used if the associated Conditions are satisfied.
*
* @ThreadSafe
* @author $Id$
*/
@ConsumerType
public interface Condition {
/**
* A Condition object that will always evaluate to true and that is never
* postponed.
*/
public final static Condition TRUE = new BooleanCondition(true);
/**
* A Condition object that will always evaluate to false and that is never
* postponed.
*/
public final static Condition FALSE = new BooleanCondition(false);
/**
* Returns whether the evaluation must be postponed until the end of the
* permission check. If this method returns {@code false} (or this Condition
* is immutable), then this Condition must be able to directly answer the
* {@link #isSatisfied()} method. In other words, isSatisfied() will return
* very quickly since no external sources, such as for example users or
* networks, need to be consulted.
* <p>
* This method must always return the same value whenever it is called so
* that the Conditional Permission Admin can cache its result.
*
* @return {@code true} to indicate the evaluation must be postponed.
* Otherwise, {@code false} if the evaluation can be performed
* immediately.
*/
boolean isPostponed();
/**
* Returns whether the Condition is satisfied. This method is only called
* for immediate Condition objects or immutable postponed conditions, and
* must always be called inside a permission check. Mutable postponed
* Condition objects will be called with the grouped version
* {@link #isSatisfied(Condition[],Dictionary)} at the end of the permission
* check.
*
* @return {@code true} to indicate the Conditions is satisfied. Otherwise,
* {@code false} if the Condition is not satisfied.
*/
boolean isSatisfied();
/**
* Returns whether the Condition is mutable. A Condition can go from mutable
* ({@code true}) to immutable ({@code false}) over time but never from
* immutable ({@code false}) to mutable ({@code true}).
*
* @return {@code true} {@link #isSatisfied()} can change. Otherwise,
* {@code false} if the value returned by {@link #isSatisfied()}
* will not change for this condition.
*/
boolean isMutable();
/**
* Returns whether the specified set of Condition objects are satisfied.
* Although this method is not static, it must be implemented as if it were
* static. All of the passed Condition objects will be of the same type and
* will correspond to the class type of the object on which this method is
* invoked. This method must be called inside a permission check only.
*
* @param conditions The array of Condition objects, which must all be of
* the same class and mutable. The receiver must be one of those
* Condition objects.
* @param context A Dictionary object that implementors can use to track
* state. If this method is invoked multiple times in the same
* permission check, the same Dictionary will be passed multiple
* times. The SecurityManager treats this Dictionary as an opaque
* object and simply creates an empty dictionary and passes it to
* subsequent invocations if multiple invocations are needed.
* @return {@code true} if all the Condition objects are satisfied.
* Otherwise, {@code false} if one of the Condition objects is not
* satisfied.
*/
boolean isSatisfied(Condition conditions[], Dictionary<Object, Object> context);
}
/**
* Package private class used to define the {@link Condition#FALSE} and
* {@link Condition#TRUE} constants.
*
* @Immutable
*/
final class BooleanCondition implements Condition {
private final boolean satisfied;
BooleanCondition(boolean satisfied) {
this.satisfied = satisfied;
}
public boolean isPostponed() {
return false;
}
public boolean isSatisfied() {
return satisfied;
}
public boolean isMutable() {
return false;
}
public boolean isSatisfied(Condition[] conds, Dictionary<Object, Object> context) {
for (int i = 0, length = conds.length; i < length; i++) {
if (!conds[i].isSatisfied())
return false;
}
return true;
}
}
|
