API Overview API Index Package Overview Direct link to this page
JDK 1.6
  javax.naming.ldap. SortControl View Javadoc
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
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204

/*
 * @(#)SortControl.java	1.4 05/11/17
 *
 * Copyright 2006 Sun Microsystems, Inc. All rights reserved.
 * SUN PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
 */

package javax.naming.ldap;

import java.io.IOException;
import com.sun.jndi.ldap.Ber;
import com.sun.jndi.ldap.BerEncoder;

/**
 * Requests that the results of a search operation be sorted by the LDAP server
 * before being returned. 
 * The sort criteria are specified using an ordered list of one or more sort 
 * keys, with associated sort parameters.
 * Search results are sorted at the LDAP server according to the parameters 
 * supplied in the sort control and then returned to the requestor. If sorting 
 * is not supported at the server (and the sort control is marked as critical) 
 * then the search operation is not performed and an error is returned.
 * <p>
 * The following code sample shows how the class may be used:
 * <pre>
 *
 *     // Open an LDAP association
 *     LdapContext ctx = new InitialLdapContext();
 *
 *     // Activate sorting
 *     String sortKey = "cn";
 *     ctx.setRequestControls(new Control[]{ 
 *         new SortControl(sortKey, Control.CRITICAL) });
 *
 *     // Perform a search
 *     NamingEnumeration results =
 *         ctx.search("", "(objectclass=*)", new SearchControls());
 *
 *     // Iterate over search results
 *     while (results != null && results.hasMore()) {
 *         // Display an entry
 *         SearchResult entry = (SearchResult)results.next();
 *         System.out.println(entry.getName());
 *         System.out.println(entry.getAttributes());
 *
 *         // Handle the entry's response controls (if any)
 *         if (entry instanceof HasControls) {
 *             // ((HasControls)entry).getControls();
 *         }
 *     }
 *     // Examine the sort control response 
 *     Control[] controls = ctx.getResponseControls();
 *     if (controls != null) {
 *         for (int i = 0; i < controls.length; i++) {
 *             if (controls[i] instanceof SortResponseControl) {
 *                 SortResponseControl src = (SortResponseControl)controls[i];
 *                 if (! src.isSorted()) {
 *                     throw src.getException();
 *                 }
 *             } else {
 *                 // Handle other response controls (if any)
 *             }
 *         }
 *     }
 *
 *     // Close the LDAP association
 *     ctx.close();
 *     ...
 *
 * </pre>
 * <p>
 * This class implements the LDAPv3 Request Control for server-side sorting
 * as defined in
 * <a href="http://www.ietf.org/rfc/rfc2891.txt">RFC 2891</a>.
 *
 * The control's value has the following ASN.1 definition:
 * <pre>
 *
 *     SortKeyList ::= SEQUENCE OF SEQUENCE {
 *         attributeType     AttributeDescription,
 *         orderingRule  [0] MatchingRuleId OPTIONAL,
 *         reverseOrder  [1] BOOLEAN DEFAULT FALSE }
 *
 * </pre>
 *
 * @since 1.5
 * @see SortKey
 * @see SortResponseControl
 * @author Vincent Ryan
 */
final public class SortControl extends BasicControl {

    /**
     * The server-side sort control's assigned object identifier
     * is 1.2.840.113556.1.4.473.
     */
    public static final String OID = "1.2.840.113556.1.4.473";

    private static final long serialVersionUID = -1965961680233330744L;

    /**
     * Constructs a control to sort on a single attribute in ascending order.
     * Sorting will be performed using the ordering matching rule defined 
     * for use with the specified attribute.
     *
     * @param	sortBy	An attribute ID to sort by.
     * @param   criticality     If true then the server must honor the control 
     *                          and return the search results sorted as 
     *                          requested or refuse to perform the search. 
     *                          If false, then the server need not honor the 
     *                          control.
     * @exception IOException If an error was encountered while encoding the 
     *                        supplied arguments into a control.
     */
    public SortControl(String sortBy, boolean criticality) throws IOException {

	super(OID, criticality, null);
	super.value = setEncodedValue(new SortKey[]{ new SortKey(sortBy) });
    }

    /**
     * Constructs a control to sort on a list of attributes in ascending order.
     * Sorting will be performed using the ordering matching rule defined 
     * for use with each of the specified attributes.
     *
     * @param	sortBy	A non-null list of attribute IDs to sort by.
     *                  The list is in order of highest to lowest sort key
     *                  precedence.
     * @param   criticality     If true then the server must honor the control 
     *                          and return the search results sorted as 
     *                          requested or refuse to perform the search. 
     *                          If false, then the server need not honor the 
     *                          control.
     * @exception IOException If an error was encountered while encoding the 
     *                        supplied arguments into a control.
     */
    public SortControl(String[] sortBy, boolean criticality)
	throws IOException {

	super(OID, criticality, null);
	SortKey[] sortKeys = new SortKey[sortBy.length];
	for (int i = 0; i < sortBy.length; i++) {
	    sortKeys[i] = new SortKey(sortBy[i]);
	}
	super.value = setEncodedValue(sortKeys);
    }

    /**
     * Constructs a control to sort on a list of sort keys.
     * Each sort key specifies the sort order and ordering matching rule to use.
     *
     * @param	sortBy	    A non-null list of keys to sort by.
     *                      The list is in order of highest to lowest sort key
     *                      precedence.
     * @param   criticality     If true then the server must honor the control 
     *                          and return the search results sorted as 
     *                          requested or refuse to perform the search. 
     *                          If false, then the server need not honor the 
     *                          control.
     * @exception IOException If an error was encountered while encoding the 
     *                        supplied arguments into a control.
     */
    public SortControl(SortKey[] sortBy, boolean criticality)
	throws IOException {

	super(OID, criticality, null);
	super.value = setEncodedValue(sortBy);
    }

    /*
     * Encodes the sort control's value using ASN.1 BER.
     * The result includes the BER tag and length for the control's value but 
     * does not include the control's object identifer and criticality setting.
     *
     * @param	sortKeys    A non-null list of keys to sort by.
     * @return A possibly null byte array representing the ASN.1 BER encoded
     *         value of the sort control.
     * @exception IOException If a BER encoding error occurs.
     */
    private byte[] setEncodedValue(SortKey[] sortKeys) throws IOException {

	// build the ASN.1 BER encoding
	BerEncoder ber = new BerEncoder(30 * sortKeys.length + 10);
	String matchingRule;

	ber.beginSeq(Ber.ASN_SEQUENCE | Ber.ASN_CONSTRUCTOR);

	for (int i = 0; i < sortKeys.length; i++) {
	    ber.beginSeq(Ber.ASN_SEQUENCE | Ber.ASN_CONSTRUCTOR);
	    ber.encodeString(sortKeys[i].getAttributeID(), true); // v3

	    if ((matchingRule = sortKeys[i].getMatchingRuleID()) != null) {
		ber.encodeString(matchingRule, (Ber.ASN_CONTEXT | 0), true);
	    }
	    if (! sortKeys[i].isAscending()) {
		ber.encodeBoolean(true, (Ber.ASN_CONTEXT | 1));
	    }
	    ber.endSeq();
	}
	ber.endSeq();

	return ber.getTrimmedBuf();
    }
}

Generated By: JavaOnTracks Doclet 0.1.4     ©Thibaut Colar