IntersectionValidityPeriod | Line # 43 | 42 | 21 | 50% |
0.5
|
(1) | |||
Result | |||
0.5
|
issrg.test.ds.TestDS.testIssuing issrg.test.ds.TestDS.testIssuing | 1 PASS | |
1 | /* | |
2 | * Copyright (c) 2000-2005, University of Salford | |
3 | * All rights reserved. | |
4 | * | |
5 | * Redistribution and use in source and binary forms, with or without | |
6 | * modification, are permitted provided that the following conditions are met: | |
7 | * | |
8 | * Redistributions of source code must retain the above copyright notice, this | |
9 | * list of conditions and the following disclaimer. | |
10 | * | |
11 | * Redistributions in binary form must reproduce the above copyright notice, | |
12 | * this list of conditions and the following disclaimer in the documentation | |
13 | * and/or other materials provided with the distribution. | |
14 | * | |
15 | * Neither the name of the University of Salford nor the names of its | |
16 | * contributors may be used to endorse or promote products derived from this | |
17 | * software without specific prior written permission. | |
18 | * | |
19 | * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" | |
20 | * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE | |
21 | * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE | |
22 | * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE | |
23 | * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR | |
24 | * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF | |
25 | * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS | |
26 | * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN | |
27 | * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) | |
28 | * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE | |
29 | * POSSIBILITY OF SUCH DAMAGE. | |
30 | */ | |
31 | ||
32 | package issrg.pba.rbac; | |
33 | ||
34 | import java.util.Date; | |
35 | ||
36 | /** | |
37 | * This class is an intersection of ValidityPeriods. It is used when the | |
38 | * intersection cannot be precomputed, e.g. when a AdjustedValidityPeriod is | |
39 | * intersected with another ValidityPeriod, or when RelativeValidityPeriods are | |
40 | * intersected - the results of both intersections will depend on the current | |
41 | * time. | |
42 | */ | |
43 | public class IntersectionValidityPeriod extends DefaultValidityPeriodBehaviour { | |
44 | ValidityPeriod vp1; | |
45 | ValidityPeriod vp2; | |
46 | ||
47 | 0 | protected IntersectionValidityPeriod() { |
48 | } | |
49 | ||
50 | /** | |
51 | * This constructor builds an intersection of two ValidityPeriods. They are | |
52 | * treated equally, and any of them can be null. If either of them is null, | |
53 | * then the result of getNotBefore and getNotAfter is provided by the | |
54 | * non-null ValidityPeriod. | |
55 | * | |
56 | * @param v1 - one ValidityPeriod | |
57 | * @param v2 - another ValidityPeriod | |
58 | */ | |
59 | 4068 | public IntersectionValidityPeriod(ValidityPeriod v1, ValidityPeriod v2){ |
60 | 4068 | vp1=v1; |
61 | 4068 | vp2=v2; |
62 | ||
63 | // the following check allows to simplify the operations | |
64 | // so that it is sufficient to test whether v1 is an AdjustedValidityPeriod, | |
65 | // and then it is not necessary to test if v2 is, see the other methods. | |
66 | 4068 | if (v2 instanceof AdjustedValidityPeriod){ // we will check for vp1 being adjustedvalidityperiod only |
67 | // if they both are adjustedvalidityperiod, the result will be "now or never" | |
68 | // (the adjusted validity period would return now for both NA and NB dates. | |
69 | // the other adjustedvalidityperiod can only change it to "never") | |
70 | 0 | vp1=v2; |
71 | 0 | vp2=v1; |
72 | } | |
73 | } | |
74 | ||
75 | /** | |
76 | * Generally, this method returns the latest of the notBefore times of the | |
77 | * ValidityPeriods. | |
78 | * | |
79 | * <p>If either of the ValidityPeriods is a | |
80 | * AdjustedValidityPeriod, the result is the notBefore time of the periods | |
81 | * adjusted against each other. If neither of the ValidityPeriods is an | |
82 | * AdjustedValidityPeriod, then the latest notBefore time of the two is | |
83 | * returned. | |
84 | * | |
85 | * @return the Date specifying the latest notBefore time of the two periods, | |
86 | * or null, if it is not constrained ("valid from time immemorial") | |
87 | */ | |
88 | 4036 | public java.util.Date getNotBefore(){ |
89 | 4036 | Date notBefore=null; |
90 | 4036 | if (vp1!=null){ |
91 | 4036 | if (vp1 instanceof AdjustedValidityPeriod){ |
92 | 0 | return ((AdjustedValidityPeriod)vp1).adjust(vp2).getNotBefore(); |
93 | } | |
94 | ||
95 | 4036 | notBefore = vp1.getNotBefore(); |
96 | } | |
97 | ||
98 | 4036 | if (vp2!=null){ |
99 | 4036 | Date d2=vp2.getNotBefore(); |
100 | 4036 | if (notBefore==null || (d2!=null && d2.after(notBefore))){ // choose the latest |
101 | // if d2 = null, then notBefore is the latest (or if it is also null, null will be reassigned) | |
102 | 2339 | notBefore=d2; |
103 | } | |
104 | } | |
105 | ||
106 | 4036 | return notBefore; |
107 | } | |
108 | ||
109 | /** | |
110 | * Generally this method returns the earliest notAfter time of the two | |
111 | * ValidityPeriods. | |
112 | * | |
113 | * <p>If either of the ValidityPeriods is a AdjustedValidityPeriod, then the | |
114 | * notAfter time of the result of adjusting one period against the other is | |
115 | * returned. If neither of them is an AdjustedValidityPeriod, then the | |
116 | * earliest notAfter time of the two ValidityPeriods is returned. | |
117 | * | |
118 | * @return the Date specifying the earliest notAfter time of the two periods, | |
119 | * or null, if it is not constrained ("valid forever") | |
120 | */ | |
121 | 4516 | public java.util.Date getNotAfter(){ |
122 | 4516 | Date notAfter=null; |
123 | 4516 | if (vp1!=null){ |
124 | 4516 | if (vp1 instanceof AdjustedValidityPeriod){ |
125 | 0 | return ((AdjustedValidityPeriod)vp1).adjust(vp2).getNotAfter(); |
126 | } | |
127 | ||
128 | 4516 | notAfter=vp1.getNotAfter(); |
129 | } | |
130 | ||
131 | 4516 | if (vp2!=null){ |
132 | 4516 | Date d2=vp2.getNotAfter(); |
133 | ||
134 | 4516 | if (notAfter==null || (d2!=null && d2.before(notAfter))){ // choose the earliest |
135 | 2935 | notAfter=d2; |
136 | } | |
137 | } | |
138 | ||
139 | 4516 | return notAfter; |
140 | } | |
141 | ||
142 | /** | |
143 | * Generally, this method tests that both ValidityPeriods contain the given | |
144 | * ValidityPeriod (the condition that the intersection of sets contains the | |
145 | * given value). | |
146 | * | |
147 | * <p>This method overrides the inherited behaviour of the contains method to | |
148 | * treat the AdjustedValidityPeriods differently. If neither of the Validity | |
149 | * Periods in the intersection is an AdjustedValidityPeriod, or the given | |
150 | * Credentials is not a ValidityPeriod, the inherited method determines | |
151 | * whether the given Credentials is contained in this ValidityPeriod. | |
152 | * | |
153 | * <p>If either of the ValidityPeriods in the intersection is an | |
154 | * AdjustedValidityPeriod, such | |
155 | * validity period is adjusted against the given ValidityPeriod. The result | |
156 | * of adjustment must still contain the given ValidityPeriod. | |
157 | * | |
158 | * @param c - the Credentials that must be contained in the intersection of | |
159 | * the ValidityPeriods (e.g. another ValidityPeriod or a | |
160 | * SetOfSubsetsCredentials containing multiple ValidityPeriods) | |
161 | * | |
162 | * @return true, if the intersection of the validity periods contains the | |
163 | * given Credentials | |
164 | */ | |
165 | 1555 | public boolean contains(issrg.pba.Credentials c){ |
166 | 1555 | if (!(vp1 instanceof AdjustedValidityPeriod || vp2 instanceof AdjustedValidityPeriod) || !(c instanceof ValidityPeriod)){ |
167 | 1555 | return super.contains(c); |
168 | } | |
169 | ||
170 | 0 | ValidityPeriod vp = (ValidityPeriod)c; |
171 | 0 | if (vp1 instanceof AdjustedValidityPeriod){ |
172 | 0 | vp=((AdjustedValidityPeriod)vp1).adjust(vp); |
173 | }else{ | |
174 | 0 | if (!vp1.contains(vp)){ |
175 | 0 | return false; |
176 | } | |
177 | } | |
178 | ||
179 | 0 | if (vp2 instanceof AdjustedValidityPeriod){ |
180 | 0 | vp=((AdjustedValidityPeriod)vp2).adjust(vp); |
181 | }else{ | |
182 | 0 | if (!vp2.contains(vp)){ |
183 | 0 | return false; |
184 | } | |
185 | } | |
186 | ||
187 | 0 | return vp.contains(c); |
188 | } | |
189 | ||
190 | /** | |
191 | * This method tells the caller if this intersection of validity periods is | |
192 | * null or not. | |
193 | */ | |
194 | 0 | public boolean isNull(){ |
195 | 0 | Date d=getNotBefore(); |
196 | 0 | Date d2=getNotAfter(); |
197 | ||
198 | 0 | return d!=null && d2!=null && d.after(d2); |
199 | } | |
200 | ||
201 | 0 | public Object clone(){ |
202 | 0 | return new IntersectionValidityPeriod(vp1==null?null:(ValidityPeriod)(vp1.clone()), vp2==null?null:(ValidityPeriod)(vp2.clone())); |
203 | } | |
204 | ||
205 | 1486 | public String toString(){ |
206 | 1486 | return "intersection of "+vp1+" "+vp2; |
207 | } | |
208 | } | |
209 |
|