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    
028    package org.opends.server.admin;
029    
030    
031    
032    import static org.opends.server.util.Validator.ensureNotNull;
033    
034    import java.util.EnumSet;
035    
036    import org.opends.server.types.DN;
037    import org.opends.server.types.DirectoryException;
038    
039    
040    
041    /**
042     * DN property definition.
043     */
044    public final class DNPropertyDefinition extends PropertyDefinition<DN> {
045    
046      // Optional base DN which all valid values must be immediately
047      // subordinate to.
048      private final DN baseDN;
049    
050    
051    
052      /**
053       * An interface for incrementally constructing DN property
054       * definitions.
055       */
056      public static class Builder extends
057          AbstractBuilder<DN, DNPropertyDefinition> {
058    
059        // Optional base DN which all valid values must be immediately
060        // subordinate to.
061        private DN baseDN = null;
062    
063    
064    
065        // Private constructor
066        private Builder(
067            AbstractManagedObjectDefinition<?, ?> d, String propertyName) {
068          super(d, propertyName);
069        }
070    
071    
072    
073        /**
074         * Set the base DN which all valid values must be immediately
075         * subordinate to. By default there is no based DN.
076         *
077         * @param baseDN
078         *          The string representation of the base DN.
079         * @throws IllegalArgumentException
080         *           If the provided string is not a valid DN string
081         *           representation.
082         */
083        public void setBaseDN(String baseDN)
084            throws IllegalArgumentException {
085          if (baseDN == null) {
086            setBaseDN((DN) null);
087          } else {
088            try {
089              setBaseDN(DN.decode(baseDN));
090            } catch (DirectoryException e) {
091              throw new IllegalArgumentException(e);
092            }
093          }
094        }
095    
096    
097    
098        /**
099         * Set the base DN which all valid values must be immediately
100         * subordinate to. By default there is no based DN.
101         *
102         * @param baseDN
103         *          The base DN.
104         */
105        public void setBaseDN(DN baseDN) {
106          this.baseDN = baseDN;
107        }
108    
109    
110    
111        /**
112         * {@inheritDoc}
113         */
114        @Override
115        protected DNPropertyDefinition buildInstance(
116            AbstractManagedObjectDefinition<?, ?> d, String propertyName,
117            EnumSet<PropertyOption> options,
118            AdministratorAction adminAction,
119            DefaultBehaviorProvider<DN> defaultBehavior) {
120          return new DNPropertyDefinition(d, propertyName, options,
121              adminAction, defaultBehavior, baseDN);
122        }
123      }
124    
125    
126    
127      /**
128       * Create a DN property definition builder.
129       *
130       * @param d
131       *          The managed object definition associated with this
132       *          property definition.
133       * @param propertyName
134       *          The property name.
135       * @return Returns the new boolean property definition builder.
136       */
137      public static Builder createBuilder(
138          AbstractManagedObjectDefinition<?, ?> d, String propertyName) {
139        return new Builder(d, propertyName);
140      }
141    
142    
143    
144      // Private constructor.
145      private DNPropertyDefinition(
146          AbstractManagedObjectDefinition<?, ?> d, String propertyName,
147          EnumSet<PropertyOption> options,
148          AdministratorAction adminAction,
149          DefaultBehaviorProvider<DN> defaultBehavior, DN baseDN) {
150        super(d, DN.class, propertyName, options, adminAction, defaultBehavior);
151        this.baseDN = baseDN;
152      }
153    
154    
155    
156      /**
157       * Get the base DN which all valid values must be immediately
158       * subordinate to, or <code>null</code> if there is no based DN.
159       *
160       * @return Returns the base DN which all valid values must be
161       *         immediately subordinate to.
162       */
163      public DN getBaseDN() {
164        return baseDN;
165      }
166    
167    
168    
169      /**
170       * {@inheritDoc}
171       */
172      @Override
173      public void validateValue(DN value)
174          throws IllegalPropertyValueException {
175        ensureNotNull(value);
176    
177        if (baseDN != null) {
178          DN parent = value.getParent();
179    
180          if (parent == null) {
181            parent = DN.nullDN();
182          }
183    
184          if (!parent.equals(baseDN)) {
185            throw new IllegalPropertyValueException(this, value);
186          }
187        }
188      }
189    
190    
191    
192      /**
193       * {@inheritDoc}
194       */
195      @Override
196      public DN decodeValue(String value)
197          throws IllegalPropertyValueStringException {
198        ensureNotNull(value);
199    
200        try {
201          DN dn = DN.decode(value);
202          validateValue(dn);
203          return dn;
204        } catch (DirectoryException e) {
205          throw new IllegalPropertyValueStringException(this, value);
206        } catch (IllegalPropertyValueException e) {
207          throw new IllegalPropertyValueStringException(this, value);
208        }
209      }
210    
211    
212    
213      /**
214       * {@inheritDoc}
215       */
216      @Override
217      public <R, P> R accept(PropertyDefinitionVisitor<R, P> v, P p) {
218        return v.visitDN(this, p);
219      }
220    
221    
222    
223      /**
224       * {@inheritDoc}
225       */
226      @Override
227      public <R, P> R accept(PropertyValueVisitor<R, P> v, DN value, P p) {
228        return v.visitDN(this, value, p);
229      }
230    
231    
232    
233      /**
234       * {@inheritDoc}
235       */
236      @Override
237      public int compare(DN o1, DN o2) {
238        return o1.compareTo(o2);
239      }
240    }