001 /*
002 * CDDL HEADER START
003 *
004 * The contents of this file are subject to the terms of the
005 * Common Development and Distribution License, Version 1.0 only
006 * (the "License"). You may not use this file except in compliance
007 * with the License.
008 *
009 * You can obtain a copy of the license at
010 * trunk/opends/resource/legal-notices/OpenDS.LICENSE
011 * or https://OpenDS.dev.java.net/OpenDS.LICENSE.
012 * See the License for the specific language governing permissions
013 * and limitations under the License.
014 *
015 * When distributing Covered Code, include this CDDL HEADER in each
016 * file and include the License file at
017 * trunk/opends/resource/legal-notices/OpenDS.LICENSE. If applicable,
018 * add the following below this CDDL HEADER, with the fields enclosed
019 * by brackets "[]" replaced with your own identifying information:
020 * Portions Copyright [yyyy] [name of copyright owner]
021 *
022 * CDDL HEADER END
023 *
024 *
025 * Copyright 2008 Sun Microsystems, Inc.
026 */
027 package org.opends.server.types;
028
029
030
031 import java.util.Collection;
032 import java.util.LinkedHashSet;
033 import java.util.List;
034
035 import org.opends.server.admin.std.server.VirtualAttributeCfg;
036 import org.opends.server.api.VirtualAttributeProvider;
037
038
039
040 /**
041 * This class defines a virtual attribute, which is a special kind of
042 * attribute whose values do not actually exist in persistent storage
043 * but rather are computed or otherwise obtained dynamically.
044 */
045 @org.opends.server.types.PublicAPI(
046 stability=org.opends.server.types.StabilityLevel.VOLATILE,
047 mayInstantiate=false,
048 mayExtend=false,
049 mayInvoke=true)
050 public final class VirtualAttribute
051 extends Attribute
052 {
053 // The entry with which this virtual attribute is associated.
054 private final Entry entry;
055
056 // The virtual attribute provider for this virtual attribute.
057 private final VirtualAttributeProvider<
058 ? extends VirtualAttributeCfg> provider;
059
060 // The virtual attribute rule for this virtual attribute.
061 private final VirtualAttributeRule rule;
062
063
064
065 /**
066 * Creates a new virtual attribute with the provided information.
067 *
068 * @param attributeType The attribute type for this virtual
069 * attribute.
070 * @param entry The entry in which this virtual attribute
071 * exists.
072 * @param rule The virutal attribute rule that governs
073 * the behavior of this virtual attribute.
074 */
075 public VirtualAttribute(AttributeType attributeType, Entry entry,
076 VirtualAttributeRule rule)
077 {
078 super(attributeType);
079
080 this.entry = entry;
081 this.rule = rule;
082
083 provider = rule.getProvider();
084 }
085
086
087
088 /**
089 * Retrieves the entry in which this virtual attribute exists.
090 *
091 * @return The entry in which this virtual attribute exists.
092 */
093 public Entry getEntry()
094 {
095 return entry;
096 }
097
098
099
100 /**
101 * Retrieves the virtual attribute rule that governs the behavior of
102 * this virtual attribute.
103 *
104 * @return The virtual attribute rule that governs the behavior of
105 * this virtual attribute.
106 */
107 public VirtualAttributeRule getVirtualAttributeRule()
108 {
109 return rule;
110 }
111
112
113
114 /**
115 * Retrieves the set of values for this attribute. The returned set
116 * of values may be altered by the caller.
117 *
118 * @return The set of values for this attribute.
119 */
120 @Override()
121 public LinkedHashSet<AttributeValue> getValues()
122 {
123 return provider.getValues(entry, rule);
124 }
125
126
127
128 /**
129 * Indicates whether this attribute contains one or more values.
130 *
131 * @return <CODE>true</CODE> if this attribute contains one or more
132 * values, or <CODE>false</CODE> if it does not.
133 */
134 @Override()
135 public boolean hasValue()
136 {
137 return provider.hasValue(entry, rule);
138 }
139
140
141
142 /**
143 * Indicates whether this attribute contains the specified value.
144 *
145 * @param value The value for which to make the determination.
146 *
147 * @return <CODE>true</CODE> if this attribute has the specified
148 * value, or <CODE>false</CODE> if not.
149 */
150 @Override()
151 public boolean hasValue(AttributeValue value)
152 {
153 return provider.hasValue(entry, rule, value);
154 }
155
156
157
158 /**
159 * Indicates whether this attribute contains all the values in the
160 * collection.
161 *
162 * @param values The set of values for which to make the
163 * determination.
164 *
165 * @return <CODE>true</CODE> if this attribute contains all the
166 * values in the provided collection, or <CODE>false</CODE>
167 * if it does not contain at least one of them.
168 */
169 @Override()
170 public boolean hasAllValues(Collection<AttributeValue> values)
171 {
172 return provider.hasAllValues(entry, rule, values);
173 }
174
175
176
177 /**
178 * Indicates whether this attribute contains any of the values in
179 * the collection.
180 *
181 * @param values The set of values for which to make the
182 * determination.
183 *
184 * @return <CODE>true</CODE> if this attribute contains at least
185 * one of the values in the provided collection, or
186 * <CODE>false</CODE> if it does not contain any of the
187 * values.
188 */
189 @Override()
190 public boolean hasAnyValue(Collection<AttributeValue> values)
191 {
192 return provider.hasAnyValue(entry, rule, values);
193 }
194
195
196
197 /**
198 * Indicates whether this attribute has any value(s) that match the
199 * provided substring.
200 *
201 * @param subInitial The subInitial component to use in the
202 * determination.
203 * @param subAny The subAny components to use in the
204 * determination.
205 * @param subFinal The subFinal component to use in the
206 * determination.
207 *
208 * @return <CODE>UNDEFINED</CODE> if this attribute does not have a
209 * substring matching rule, <CODE>TRUE</CODE> if at least
210 * one value matches the provided substring, or
211 * <CODE>FALSE</CODE> otherwise.
212 */
213 @Override()
214 public ConditionResult matchesSubstring(ByteString subInitial,
215 List<ByteString> subAny,
216 ByteString subFinal)
217 {
218 return provider.matchesSubstring(entry, rule, subInitial, subAny,
219 subFinal);
220 }
221
222
223
224 /**
225 * Indicates whether this attribute has any value(s) that are
226 * greater than or equal to the provided value.
227 *
228 * @param value The value for which to make the determination.
229 *
230 * @return <CODE>UNDEFINED</CODE> if this attribute does not have
231 * an ordering matching rule, <CODE>TRUE</CODE> if at least
232 * one value is greater than or equal to the provided
233 * value, or <CODE>false</CODE> otherwise.
234 */
235 @Override()
236 public ConditionResult greaterThanOrEqualTo(AttributeValue value)
237 {
238 return provider.greaterThanOrEqualTo(entry, rule, value);
239 }
240
241
242
243 /**
244 * Indicates whether this attribute has any value(s) that are less
245 * than or equal to the provided value.
246 *
247 * @param value The value for which to make the determination.
248 *
249 * @return <CODE>UNDEFINED</CODE> if this attribute does not have
250 * an ordering matching rule, <CODE>TRUE</CODE> if at least
251 * one value is less than or equal to the provided value,
252 * or <CODE>false</CODE> otherwise.
253 */
254 @Override()
255 public ConditionResult lessThanOrEqualTo(AttributeValue value)
256 {
257 return provider.lessThanOrEqualTo(entry, rule, value);
258 }
259
260
261
262 /**
263 * Indicates whether this attribute has any value(s) that are
264 * approximately equal to the provided value.
265 *
266 * @param value The value for which to make the determination.
267 *
268 * @return <CODE>UNDEFINED</CODE> if this attribute does not have
269 * an approximate matching rule, <CODE>TRUE</CODE> if at
270 * least one value is approximately equal to the provided
271 * value, or <CODE>false</CODE> otherwise.
272 */
273 @Override()
274 public ConditionResult approximatelyEqualTo(AttributeValue value)
275 {
276 return provider.approximatelyEqualTo(entry, rule, value);
277 }
278
279
280
281 /**
282 * Indicates whether this is a virtual attribute rather than a real
283 * attribute.
284 *
285 * @return {@code true} if this is a virtual attribute, or
286 * {@code false} if it is a real attribute.
287 */
288 @Override()
289 public boolean isVirtual()
290 {
291 return true;
292 }
293
294
295
296 /**
297 * Creates a duplicate of this attribute that can be modified
298 * without impacting this attribute.
299 *
300 * @param omitValues <CODE>true</CODE> if the values should be
301 * omitted.
302 *
303 * @return A duplicate of this attribute that can be modified
304 * without impacting this attribute.
305 */
306 @Override()
307 public Attribute duplicate(boolean omitValues)
308 {
309 return new VirtualAttribute(getAttributeType(), entry, rule);
310 }
311
312
313
314 /**
315 * Appends a one-line string representation of this attribute to the
316 * provided buffer.
317 *
318 * @param buffer The buffer to which the information should be
319 * appended.
320 */
321 @Override()
322 public void toString(StringBuilder buffer)
323 {
324 buffer.append("VirtualAttribute(");
325 buffer.append(getAttributeType().getNameOrOID());
326 buffer.append(", {");
327
328 boolean firstValue = true;
329 for (AttributeValue value : getValues())
330 {
331 if (! firstValue)
332 {
333 buffer.append(", ");
334 }
335
336 value.toString(buffer);
337 firstValue = false;
338 }
339
340 buffer.append("})");
341 }
342 }
343