1 /*
2 * Licensed to the Apache Software Foundation (ASF) under one
3 * or more contributor license agreements. See the NOTICE file
4 * distributed with this work for additional information
5 * regarding copyright ownership. The ASF licenses this file
6 * to you under the Apache License, Version 2.0 (the
7 * "License"); you may not use this file except in compliance
8 * with the License. You may obtain a copy of the License at
9 *
10 * http://www.apache.org/licenses/LICENSE-2.0
11 *
12 * Unless required by applicable law or agreed to in writing,
13 * software distributed under the License is distributed on an
14 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
15 * KIND, either express or implied. See the License for the
16 * specific language governing permissions and limitations
17 * under the License.
18 *
19 */
20 package org.apache.directory.api.ldap.model.schema;
21
22
23 import java.util.ArrayList;
24 import java.util.List;
25
26 import org.apache.directory.api.i18n.I18n;
27
28
29 /**
30 * A dITStructureRule definition. A dITStructureRules is a rule governing the
31 * structure of the DIT by specifying a permitted superior to subordinate entry
32 * relationship. A structure rule relates a nameForm, and therefore a STRUCTURAL
33 * objectClass, to superior dITStructureRules. This permits entries of the
34 * STRUCTURAL objectClass identified by the nameForm to exist in the DIT as
35 * subordinates to entries governed by the indicated superior dITStructureRules.
36 * Hence dITStructureRules only apply to structural object classes.
37 * <p>
38 * According to ldapbis [MODELS]:
39 * </p>
40 *
41 * <pre>
42 * DIT structure rule descriptions are written according to the ABNF:
43 *
44 * DITStructureRuleDescription = LPAREN WSP
45 * ruleid ; rule identifier
46 * [ SP "NAME" SP qdescrs ] ; short names (descriptors)
47 * [ SP "DESC" SP qdstring ] ; description
48 * [ SP "OBSOLETE" ] ; not active
49 * SP "FORM" SP oid ; NameForm
50 * [ SP "SUP" ruleids ] ; superior rules
51 * extensions WSP RPAREN ; extensions
52 *
53 * ruleids = ruleid / ( LPAREN WSP ruleidlist WSP RPAREN )
54 *
55 * ruleidlist = ruleid *( SP ruleid )
56 *
57 * ruleid = number
58 *
59 * where:
60 * [ruleid] is the rule identifier of this DIT structure rule;
61 * NAME [qdescrs] are short names (descriptors) identifying this DIT
62 * structure rule;
63 * DESC [qdstring] is a short descriptive string;
64 * OBSOLETE indicates this DIT structure rule use is not active;
65 * FORM is specifies the name form associated with this DIT structure
66 * rule;
67 * SUP identifies superior rules (by rule id); and
68 * [extensions] describe extensions.
69 *
70 * If no superior rules are identified, the DIT structure rule applies
71 * to an autonomous administrative point (e.g. the root vertex of the
72 * subtree controlled by the subschema) [X.501].
73 * </pre>
74 *
75 * @see <a href="http://www.faqs.org/rfcs/rfc2252.html">RFC2252 Section 6.33</a>
76 * @see <a
77 * href="http://www.ietf.org/internet-drafts/draft-ietf-ldapbis-models-11.txt">ldapbis
78 * [MODELS]</a>
79 * @author <a href="mailto:dev@directory.apache.org">Apache Directory Project</a>
80 */
81 public class DitStructureRule extends AbstractSchemaObject
82 {
83 /** The mandatory serialVersionUID */
84 public static final long serialVersionUID = 1L;
85
86 /** The rule ID. A DSR does not have an OID */
87 private int ruleId;
88
89 /** The associated NameForm */
90 private String form;
91
92 /** The list of superiors rules */
93 private List<Integer> superRules;
94
95
96 /**
97 * Creates a new instance of DitStructureRule
98 *
99 * @param ruleId The RuleId for this DitStructureRule
100 */
101 public DitStructureRule( int ruleId )
102 {
103 super( SchemaObjectType.DIT_STRUCTURE_RULE, null );
104 this.ruleId = ruleId;
105 form = null;
106 superRules = new ArrayList<>();
107 }
108
109
110 /**
111 * @return The associated NameForm's OID
112 */
113 public String getForm()
114 {
115 return form;
116 }
117
118
119 /**
120 * Sets the associated NameForm's OID
121 *
122 * @param form The NameForm's OID
123 */
124 public void setForm( String form )
125 {
126 if ( locked )
127 {
128 throw new UnsupportedOperationException( I18n.err( I18n.ERR_04441, getName() ) );
129 }
130
131 if ( !isReadOnly )
132 {
133 this.form = form;
134 }
135 }
136
137
138 /**
139 * @return The Rule ID
140 */
141 public int getRuleId()
142 {
143 return ruleId;
144 }
145
146
147 /**
148 * Sets the rule identifier of this DIT structure rule;
149 *
150 * @param ruleId the rule identifier of this DIT structure rule;
151 */
152 public void setRuleId( int ruleId )
153 {
154 if ( locked )
155 {
156 throw new UnsupportedOperationException( I18n.err( I18n.ERR_04441, getName() ) );
157 }
158
159 if ( !isReadOnly )
160 {
161 this.ruleId = ruleId;
162 }
163 }
164
165
166 /**
167 * @return The list of superiors RuleIDs
168 */
169 public List<Integer> getSuperRules()
170 {
171 return superRules;
172 }
173
174
175 /**
176 * Sets the list of superior RuleIds
177 *
178 * @param superRules the list of superior RuleIds
179 */
180 public void setSuperRules( List<Integer> superRules )
181 {
182 if ( locked )
183 {
184 throw new UnsupportedOperationException( I18n.err( I18n.ERR_04441, getName() ) );
185 }
186
187 if ( !isReadOnly )
188 {
189 this.superRules = superRules;
190 }
191 }
192
193
194 /**
195 * Adds a new superior RuleId
196 *
197 * @param superRule The superior RuleID to add
198 */
199 public void addSuperRule( Integer superRule )
200 {
201 if ( locked )
202 {
203 throw new UnsupportedOperationException( I18n.err( I18n.ERR_04441, getName() ) );
204 }
205
206 superRules.add( superRule );
207 }
208
209
210 /**
211 * The DIT structure rule does not have an OID
212 *
213 * {@inheritDoc}
214 */
215 @Override
216 public String getOid()
217 {
218 // We cannot throw exception here. E.g. SchemaObjectWrapper will try to use this in hashcode.
219 return null;
220 }
221
222
223 /**
224 * {@inheritDoc}
225 */
226 @Override
227 public String toString()
228 {
229 return SchemaObjectRenderer.OPEN_LDAP_SCHEMA_RENDERER.render( this );
230 }
231
232
233 /**
234 * {@inheritDoc}
235 */
236 @Override
237 public DitStructureRule copy()
238 {
239 DitStructureRule copy = new DitStructureRule( ruleId );
240
241 // Copy the SchemaObject common data
242 copy.copy( this );
243
244 // Copy the Superiors rules
245 copy.superRules = new ArrayList<>();
246
247 // Copy the form
248 copy.form = form;
249
250 for ( int superRule : superRules )
251 {
252 copy.superRules.add( superRule );
253 }
254
255 return copy;
256 }
257
258
259 /**
260 * {@inheritDoc}
261 */
262 @Override
263 public boolean equals( Object o )
264 {
265 if ( !super.equals( o ) )
266 {
267 return false;
268 }
269
270 if ( !( o instanceof DitStructureRule ) )
271 {
272 return false;
273 }
274
275 @SuppressWarnings("unused")
276 DitStructureRule that = ( DitStructureRule ) o;
277
278 // TODO : complete the test
279 return true;
280 }
281
282
283 /**
284 * {@inheritDoc}
285 */
286 @Override
287 public void clear()
288 {
289 // Clear the common elements
290 super.clear();
291
292 // Clear the references
293 superRules.clear();
294 }
295 }