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 package org.opends.server.types; 028 029 030 031 import org.opends.messages.Message; 032 import org.opends.server.api.CompressedSchema; 033 import org.opends.server.core.DirectoryServer; 034 035 import static org.opends.messages.CoreMessages.*; 036 037 038 039 /** 040 * This class defines a data structure that contains configuration 041 * information about how an entry should be encoded. 042 */ 043 @org.opends.server.types.PublicAPI( 044 stability=org.opends.server.types.StabilityLevel.VOLATILE, 045 mayInstantiate=true, 046 mayExtend=false, 047 mayInvoke=true) 048 public final class EntryEncodeConfig 049 { 050 /** 051 * The encode mask value that can be used to indicate that the 052 * encoded entry should not contain a DN. 053 */ 054 private static final byte ENCODE_FLAG_EXCLUDE_DN = 0x01; 055 056 057 058 /** 059 * The encode mask value that can be used that the encoded 060 * representation should compress the set of object classes. 061 */ 062 private static final byte ENCODE_FLAG_COMPRESS_OCS = 0x02; 063 064 065 066 /** 067 * The encode mask value that can be used that the encoded 068 * representation should compress the set of attribute descriptions 069 * to conserve space and improve performance. 070 */ 071 private static final byte ENCODE_FLAG_COMPRESS_ADS = 0x04; 072 073 074 075 /** 076 * A reference to an entry encode configuration with all the default 077 * settings. 078 */ 079 public static final EntryEncodeConfig 080 DEFAULT_CONFIG = new EntryEncodeConfig(); 081 082 083 084 // Indicates whether to compress the attribute descriptions. 085 private final boolean compressAttrDescriptions; 086 087 // Indicates whether to compress the object class sets. 088 private final boolean compressObjectClassSets; 089 090 // Indicates whether to exclude the DN. 091 private final boolean excludeDN; 092 093 // The encoded representation of this encode configuration. 094 private final byte[] encodedRepresentation; 095 096 // The compressed schema handler for this encode configuration. 097 private final CompressedSchema compressedSchema; 098 099 100 101 /** 102 * Creates a new encoded entry configuration wtih the default 103 * settings. 104 */ 105 public EntryEncodeConfig() 106 { 107 excludeDN = false; 108 compressAttrDescriptions = false; 109 compressObjectClassSets = false; 110 111 compressedSchema = DirectoryServer.getDefaultCompressedSchema(); 112 113 encodedRepresentation = new byte[] { 0x00 }; 114 } 115 116 117 118 /** 119 * Creates a new encoded entry configuration wtih the specified 120 * settings. 121 * 122 * @param excludeDN Indicates whether to exclude 123 * the DN from the encoded entry. 124 * @param compressAttrDescriptions Indicates whether to compress 125 * attribute descriptions. 126 * @param compressObjectClassSets Indicates whether to compress 127 * object class sets. 128 */ 129 public EntryEncodeConfig(boolean excludeDN, 130 boolean compressAttrDescriptions, 131 boolean compressObjectClassSets) 132 { 133 this.excludeDN = excludeDN; 134 this.compressAttrDescriptions = compressAttrDescriptions; 135 this.compressObjectClassSets = compressObjectClassSets; 136 137 compressedSchema = DirectoryServer.getDefaultCompressedSchema(); 138 139 byte flagByte = 0x00; 140 if (excludeDN) 141 { 142 flagByte |= ENCODE_FLAG_EXCLUDE_DN; 143 } 144 145 if (compressAttrDescriptions) 146 { 147 flagByte |= ENCODE_FLAG_COMPRESS_ADS; 148 } 149 150 if (compressObjectClassSets) 151 { 152 flagByte |= ENCODE_FLAG_COMPRESS_OCS; 153 } 154 155 encodedRepresentation = new byte[] { flagByte }; 156 } 157 158 159 160 /** 161 * Creates a new encoded entry configuration wtih the specified 162 * settings. 163 * 164 * @param excludeDN Indicates whether to exclude 165 * the DN from the encoded entry. 166 * @param compressAttrDescriptions Indicates whether to compress 167 * attribute descriptions. 168 * @param compressObjectClassSets Indicates whether to compress 169 * object class sets. 170 * @param compressedSchema The compressed schema manager 171 * for this encode config. 172 */ 173 public EntryEncodeConfig(boolean excludeDN, 174 boolean compressAttrDescriptions, 175 boolean compressObjectClassSets, 176 CompressedSchema compressedSchema) 177 { 178 this.excludeDN = excludeDN; 179 this.compressAttrDescriptions = compressAttrDescriptions; 180 this.compressObjectClassSets = compressObjectClassSets; 181 this.compressedSchema = compressedSchema; 182 183 byte flagByte = 0x00; 184 if (excludeDN) 185 { 186 flagByte |= ENCODE_FLAG_EXCLUDE_DN; 187 } 188 189 if (compressAttrDescriptions) 190 { 191 flagByte |= ENCODE_FLAG_COMPRESS_ADS; 192 } 193 194 if (compressObjectClassSets) 195 { 196 flagByte |= ENCODE_FLAG_COMPRESS_OCS; 197 } 198 199 encodedRepresentation = new byte[] { flagByte }; 200 } 201 202 203 204 /** 205 * Indicates whether the encoded entry should exclude the DN. 206 * 207 * @return {@code true} if the encoded entry should exclude the DN, 208 * or {@code false} if not. 209 */ 210 public boolean excludeDN() 211 { 212 return excludeDN; 213 } 214 215 216 217 /** 218 * Indicates whether the encoded entry should use compressed 219 * attribute descriptions. 220 * 221 * @return {@code true} if the encoded entry should use compressed 222 * attribute descriptions, or {@code false} if not. 223 */ 224 public boolean compressAttributeDescriptions() 225 { 226 return compressAttrDescriptions; 227 } 228 229 230 231 /** 232 * Indicates whether the encoded entry should use compressed object 233 * class sets. 234 * 235 * @return {@code true} if the encoded entry should use compressed 236 * object class sets, or {@code false} if not. 237 */ 238 public boolean compressObjectClassSets() 239 { 240 return compressObjectClassSets; 241 } 242 243 244 245 /** 246 * Retrieves the compressed schema manager that may be used to 247 * generate compact schema encodings with this entry encode 248 * configuration. 249 * 250 * @return The compressed schema manager that may be used to 251 * generate compact schema encodings with this entry encode 252 * configuration. 253 */ 254 public CompressedSchema getCompressedSchema() 255 { 256 return compressedSchema; 257 } 258 259 260 261 /** 262 * Encodes this entry encode configuration into a byte array 263 * suitable for inclusion in the encoded entry. 264 * 265 * @return A byte array containing the encoded configuration. 266 */ 267 public byte[] encode() 268 { 269 return encodedRepresentation; 270 } 271 272 273 274 /** 275 * Decodes the entry encode configuration from the specified portion 276 * of the given byte array. 277 * 278 * @param encodedEntry The byte array containing the encoded 279 * entry. 280 * @param startPos The position at which to start decoding 281 * the encode configuration. 282 * @param length The number of bytes contained in the 283 * encode configuration. 284 * @param compressedSchema The compressed schema manager to use 285 * when decoding. 286 * 287 * @return The decoded configuration. 288 * 289 * @throws DirectoryException If the configuration cannot be 290 * properly decoded. 291 */ 292 public static EntryEncodeConfig 293 decode(byte[] encodedEntry, int startPos, 294 int length, CompressedSchema compressedSchema) 295 throws DirectoryException 296 { 297 if (length != 1) 298 { 299 Message message = ERR_ENTRYENCODECFG_INVALID_LENGTH.get(); 300 throw new DirectoryException( 301 DirectoryServer.getServerErrorResultCode(), 302 message); 303 } 304 305 boolean excludeDN = false; 306 if ((encodedEntry[startPos] & ENCODE_FLAG_EXCLUDE_DN) == 307 ENCODE_FLAG_EXCLUDE_DN) 308 { 309 excludeDN = true; 310 } 311 312 boolean compressAttrDescriptions = false; 313 if ((encodedEntry[startPos] & ENCODE_FLAG_COMPRESS_ADS) == 314 ENCODE_FLAG_COMPRESS_ADS) 315 { 316 compressAttrDescriptions = true; 317 } 318 319 boolean compressObjectClassSets = false; 320 if ((encodedEntry[startPos] & ENCODE_FLAG_COMPRESS_OCS) == 321 ENCODE_FLAG_COMPRESS_OCS) 322 { 323 compressObjectClassSets = true; 324 } 325 326 return new EntryEncodeConfig(excludeDN, compressAttrDescriptions, 327 compressObjectClassSets, 328 compressedSchema); 329 } 330 331 332 333 /** 334 * Retrieves a string representation of this entry encode 335 * configuration. 336 * 337 * @return A string representation of this entry encode 338 * configuration. 339 */ 340 public String toString() 341 { 342 StringBuilder buffer = new StringBuilder(); 343 toString(buffer); 344 return buffer.toString(); 345 } 346 347 348 349 /** 350 * Appends a string representation of this entry encode 351 * configuration to the provided buffer. 352 * 353 * @param buffer The buffer to which the information should be 354 * appended. 355 */ 356 public void toString(StringBuilder buffer) 357 { 358 buffer.append("EntryEncodeConfig(excludeDN="); 359 buffer.append(excludeDN); 360 buffer.append(", compressAttrDescriptions="); 361 buffer.append(compressAttrDescriptions); 362 buffer.append(", compressObjectClassSets="); 363 buffer.append(compressObjectClassSets); 364 buffer.append(")"); 365 } 366 } 367