001 /* 002 * Copyright 2014-2015 UnboundID Corp. 003 * All Rights Reserved. 004 */ 005 /* 006 * Copyright (C) 2015 UnboundID Corp. 007 * 008 * This program is free software; you can redistribute it and/or modify 009 * it under the terms of the GNU General Public License (GPLv2 only) 010 * or the terms of the GNU Lesser General Public License (LGPLv2.1 only) 011 * as published by the Free Software Foundation. 012 * 013 * This program is distributed in the hope that it will be useful, 014 * but WITHOUT ANY WARRANTY; without even the implied warranty of 015 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 016 * GNU General Public License for more details. 017 * 018 * You should have received a copy of the GNU General Public License 019 * along with this program; if not, see <http://www.gnu.org/licenses>. 020 */ 021 package com.unboundid.ldap.sdk.unboundidds.controls; 022 023 024 025 import com.unboundid.util.ThreadSafety; 026 import com.unboundid.util.ThreadSafetyLevel; 027 028 029 030 /** 031 * <BLOCKQUOTE> 032 * <B>NOTE:</B> This class is part of the Commercial Edition of the UnboundID 033 * LDAP SDK for Java. It is not available for use in applications that 034 * include only the Standard Edition of the LDAP SDK, and is not supported for 035 * use in conjunction with non-UnboundID products. 036 * </BLOCKQUOTE> 037 * This enum defines the set of count types that may be used in a matching entry 038 * count response control. 039 */ 040 @ThreadSafety(level=ThreadSafetyLevel.COMPLETELY_THREADSAFE) 041 public enum MatchingEntryCountType 042 { 043 /** 044 * The count type that indicates that the server was able to determine the 045 * exact number of entries matching the search criteria and examined them to 046 * exclude any entries that would not be returned to the client in the course 047 * of processing a normal search with the same criteria. 048 */ 049 EXAMINED_COUNT((byte) 0x80), 050 051 052 053 /** 054 * The count type that indicates that the server was able to determine the 055 * exact number of entries matching the search criteria, but did not examine 056 * them to exclude any entries that might not actually be returned to the 057 * client in the course of processing a normal search with the same criteria 058 * (e.g., entries that the requester doesn't have permission to access, or 059 * entries like LDAP subentries, replication conflict entries, or soft-deleted 060 * entries that are returned only for special types of requests). 061 */ 062 UNEXAMINED_COUNT((byte) 0x81), 063 064 065 066 /** 067 * The count type that indicates that the server was unable to determine the 068 * exact number of entries matching the search criteria, but was able to 069 * determine an upper bound for the number of matching entries. 070 */ 071 UPPER_BOUND((byte) 0x82), 072 073 074 075 /** 076 * The count type that indicates that the server was unable to make any 077 * meaningful determination about the number of entries matching the search 078 * criteria. 079 */ 080 UNKNOWN((byte) 0x83); 081 082 083 084 // The BER type that corresponds to this enum value. 085 private final byte berType; 086 087 088 089 /** 090 * Creates a new count type value with the provided information. 091 * 092 * @param berType The BER type that corresponds to this enum value. 093 */ 094 MatchingEntryCountType(final byte berType) 095 { 096 this.berType = berType; 097 } 098 099 100 101 /** 102 * Retrieves the BER type for this count type value. 103 * 104 * @return The BER type for this count type value. 105 */ 106 public byte getBERType() 107 { 108 return berType; 109 } 110 111 112 113 /** 114 * Indicates whether this matching entry count type is considered more 115 * specific than the provided count type. The following order of precedence, 116 * from most specific to least specific, will be used: 117 * <OL> 118 * <LI>EXAMINED_COUNT</LI> 119 * <LI>UNEXAMINED_COUNT</LI> 120 * <LI>UPPER_BOUND</LI> 121 * <LI>UNKNOWN</LI> 122 * </OL> 123 * 124 * @param t The matching entry count type value to compare against this 125 * matching entry count type. It must not be {@code null}. 126 * 127 * @return {@code true} if the provided matching entry count type value is 128 * considered more specific than this matching entry count type, or 129 * {@code false} if the provided count type is the same as or less 130 * specific than this count type. 131 */ 132 public boolean isMoreSpecificThan(final MatchingEntryCountType t) 133 { 134 switch (this) 135 { 136 case EXAMINED_COUNT: 137 return (t != EXAMINED_COUNT); 138 139 case UNEXAMINED_COUNT: 140 return ((t != EXAMINED_COUNT) && (t != UNEXAMINED_COUNT)); 141 142 case UPPER_BOUND: 143 return ((t != EXAMINED_COUNT) && (t != UNEXAMINED_COUNT) && 144 (t != UPPER_BOUND)); 145 146 case UNKNOWN: 147 default: 148 return false; 149 } 150 } 151 152 153 154 /** 155 * Indicates whether this matching entry count type is considered less 156 * specific than the provided count type. The following order of precedence, 157 * from most specific to least specific, will be used: 158 * <OL> 159 * <LI>EXAMINED_COUNT</LI> 160 * <LI>UNEXAMINED_COUNT</LI> 161 * <LI>UPPER_BOUND</LI> 162 * <LI>UNKNOWN</LI> 163 * </OL> 164 * 165 * @param t The matching entry count type value to compare against this 166 * matching entry count type. It must not be {@code null}. 167 * 168 * @return {@code true} if the provided matching entry count type value is 169 * considered less specific than this matching entry count type, or 170 * {@code false} if the provided count type is the same as or more 171 * specific than this count type. 172 */ 173 public boolean isLessSpecificThan(final MatchingEntryCountType t) 174 { 175 switch (this) 176 { 177 case UNKNOWN: 178 return (t != UNKNOWN); 179 180 case UPPER_BOUND: 181 return ((t != UNKNOWN) && (t != UPPER_BOUND)); 182 183 case UNEXAMINED_COUNT: 184 return ((t != UNKNOWN) && (t != UPPER_BOUND) && 185 (t != UNEXAMINED_COUNT)); 186 187 case EXAMINED_COUNT: 188 default: 189 return false; 190 } 191 } 192 193 194 195 /** 196 * Retrieves the count type value for the provided BER type. 197 * 198 * @param berType The BER type for the count type value to retrieve. 199 * 200 * @return The count type value that corresponds to the provided BER type, or 201 * {@code null} if there is no corresponding count type value. 202 */ 203 public static MatchingEntryCountType valueOf(final byte berType) 204 { 205 for (final MatchingEntryCountType t : values()) 206 { 207 if (t.berType == berType) 208 { 209 return t; 210 } 211 } 212 213 return null; 214 } 215 }