mirror of https://github.com/OpenIdentityPlatform/OpenDJ.git

Matthew Swift
28.32.2013 a33a4959bae9ae6b119d5049609e4b439f911ee1
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License, Version 1.0 only
 * (the "License").  You may not use this file except in compliance
 * with the License.
 *
 * You can obtain a copy of the license at legal-notices/CDDLv1_0.txt
 * or http://forgerock.org/license/CDDLv1.0.html.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at legal-notices/CDDLv1_0.txt.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information:
 *      Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 *
 *
 *      Copyright 2010 Sun Microsystems, Inc.
 *      Portions copyright 2012-2013 ForgeRock AS.
 */
 
package org.forgerock.opendj.ldap.requests;
 
import java.util.LinkedList;
import java.util.List;
 
import org.forgerock.opendj.ldap.DecodeException;
import org.forgerock.opendj.ldap.DecodeOptions;
import org.forgerock.opendj.ldap.controls.Control;
import org.forgerock.opendj.ldap.controls.ControlDecoder;
import org.forgerock.opendj.ldap.controls.GenericControl;
 
import com.forgerock.opendj.util.Validator;
 
/**
 * Abstract request implementation.
 *
 * @param <R>
 *            The type of request.
 */
abstract class AbstractRequestImpl<R extends Request> implements Request {
 
    // Used by unmodifiable implementations as well.
    static Control getControl(final List<Control> controls, final String oid) {
        // Avoid creating an iterator if possible.
        if (!controls.isEmpty()) {
            for (final Control control : controls) {
                if (control.getOID().equals(oid)) {
                    return control;
                }
            }
        }
        return null;
    }
 
    private final List<Control> controls = new LinkedList<Control>();
 
    /**
     * Creates a new abstract request implementation.
     */
    AbstractRequestImpl() {
        // No implementation required.
    }
 
    /**
     * Creates a new abstract request that is an exact copy of the provided
     * request.
     *
     * @param request
     *            The request to be copied.
     * @throws NullPointerException
     *             If {@code request} was {@code null} .
     */
    AbstractRequestImpl(final Request request) {
        Validator.ensureNotNull(request);
        for (final Control control : request.getControls()) {
            // Create defensive copy.
            controls.add(GenericControl.newControl(control));
        }
    }
 
    /**
     * {@inheritDoc}
     */
    @Override
    public final R addControl(final Control control) {
        Validator.ensureNotNull(control);
        controls.add(control);
        return getThis();
    }
 
    /**
     * {@inheritDoc}
     */
    @Override
    public boolean containsControl(final String oid) {
        return getControl(controls, oid) != null;
    }
 
    /**
     * {@inheritDoc}
     */
    @Override
    public final <C extends Control> C getControl(final ControlDecoder<C> decoder,
            final DecodeOptions options) throws DecodeException {
        Validator.ensureNotNull(decoder, options);
        final Control control = getControl(controls, decoder.getOID());
        return control != null ? decoder.decodeControl(control, options) : null;
    }
 
    /**
     * {@inheritDoc}
     */
    @Override
    public final List<Control> getControls() {
        return controls;
    }
 
    @Override
    public abstract String toString();
 
    abstract R getThis();
 
}