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    /**
033     * A managed object composite relationship definition which represents
034     * a composition of an optional single managed object (i.e. the
035     * referenced managed object may or may not be present).
036     *
037     * @param <C>
038     *          The type of client managed object configuration that this
039     *          relation definition refers to.
040     * @param <S>
041     *          The type of server managed object configuration that this
042     *          relation definition refers to.
043     */
044    public final class OptionalRelationDefinition
045        <C extends ConfigurationClient, S extends Configuration>
046        extends RelationDefinition<C, S> {
047    
048      /**
049       * An interface for incrementally constructing optional relation
050       * definitions.
051       *
052       * @param <C>
053       *          The type of client managed object configuration that
054       *          this relation definition refers to.
055       * @param <S>
056       *          The type of server managed object configuration that
057       *          this relation definition refers to.
058       */
059      public static final class Builder
060          <C extends ConfigurationClient, S extends Configuration>
061          extends AbstractBuilder<C, S, OptionalRelationDefinition<C, S>> {
062    
063        // The optional default managed object associated with this
064        // optional relation.
065        private DefaultManagedObject<? extends C, ? extends S>
066          defaultManagedObject = null;
067    
068    
069    
070        /**
071         * Creates a new builder which can be used to incrementally build
072         * an optional relation definition.
073         *
074         * @param pd
075         *          The parent managed object definition.
076         * @param name
077         *          The name of the relation.
078         * @param cd
079         *          The child managed object definition.
080         */
081        public Builder(AbstractManagedObjectDefinition<?, ?> pd, String name,
082            AbstractManagedObjectDefinition<C, S> cd) {
083          super(pd, name, cd);
084        }
085    
086    
087    
088        /**
089         * Sets the optional default managed object associated with this
090         * optional relation definition.
091         *
092         * @param defaultManagedObject
093         *          The default managed object or <code>null</code> if
094         *          there is no default managed object defined for this
095         *          relation definition.
096         */
097        public void setDefaultManagedObject(
098            DefaultManagedObject<? extends C, ? extends S> defaultManagedObject) {
099          this.defaultManagedObject = defaultManagedObject;
100        }
101    
102    
103    
104        /**
105         * {@inheritDoc}
106         */
107        @Override
108        protected OptionalRelationDefinition<C, S> buildInstance(
109            Common<C, S> common) {
110          return new OptionalRelationDefinition<C, S>(common, defaultManagedObject);
111        }
112    
113      }
114    
115    
116    
117      // The optional default managed object associated with this
118      // optional relation.
119      private final DefaultManagedObject<? extends C, ? extends S>
120        defaultManagedObject;
121    
122    
123    
124      // Private constructor.
125      private OptionalRelationDefinition(Common<C, S> common,
126          DefaultManagedObject<? extends C, ? extends S> defaultManagedObject) {
127        super(common);
128        this.defaultManagedObject = defaultManagedObject;
129      }
130    
131    
132    
133      /**
134       * {@inheritDoc}
135       */
136      @Override
137      public <R, P> R accept(RelationDefinitionVisitor<R, P> v, P p) {
138        return v.visitOptional(this, p);
139      }
140    
141    
142    
143      /**
144       * Gets the optional default managed object associated with this
145       * optional relation definition.
146       *
147       * @return Returns the default managed object or <code>null</code>
148       *         if there is no default managed object defined for this
149       *         relation definition.
150       */
151      public DefaultManagedObject<? extends C, ? extends S>
152          getDefaultManagedObject() {
153        return defaultManagedObject;
154      }
155    
156    
157    
158      /**
159       * {@inheritDoc}
160       */
161      @Override
162      public void toString(StringBuilder builder) {
163        builder.append("name=");
164        builder.append(getName());
165        builder.append(" type=composition parent=");
166        builder.append(getParentDefinition().getName());
167        builder.append(" child=");
168        builder.append(getChildDefinition().getName());
169        builder.append(" minOccurs=0 maxOccurs=1");
170      }
171    
172    
173    
174      /**
175       * {@inheritDoc}
176       */
177      @Override
178      protected void initialize() throws Exception {
179        if (defaultManagedObject != null) {
180          defaultManagedObject.initialize();
181        }
182      }
183    
184    }