001 /*
002 * Licensed to the Apache Software Foundation (ASF) under one
003 * or more contributor license agreements. See the NOTICE file
004 * distributed with this work for additional information
005 * regarding copyright ownership. The ASF licenses this file
006 * to you under the Apache License, Version 2.0 (the
007 * "License"); you may not use this file except in compliance
008 * with the License. You may obtain a copy of the License at
009 *
010 * http://www.apache.org/licenses/LICENSE-2.0
011 *
012 * Unless required by applicable law or agreed to in writing,
013 * software distributed under the License is distributed on an
014 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
015 * KIND, either express or implied. See the License for the
016 * specific language governing permissions and limitations
017 * under the License.
018 *
019 */
020 package org.apache.directory.shared.ldap.message;
021
022
023 import java.util.Map;
024
025 import org.apache.directory.shared.i18n.I18n;
026 import org.apache.directory.shared.ldap.constants.JndiPropertyConstants;
027
028
029 /**
030 * Type-safe derefAliases search parameter enumeration which determines the mode
031 * of alias handling. Note that the jndi values of these ValuedEnums correspond
032 * to the string value for the java.naming.ldap.derefAliases JNDI LDAP specific
033 * property. The integer value represents the values used in the LDAP ASN.1 for
034 * different settings.
035 *
036 * @author <a href="mailto:dev@directory.apache.org">Apache Directory Project</a>
037 * @version $Revision: 912436 $
038 */
039 public enum AliasDerefMode
040 {
041 /** Alias handling mode value that treats aliases like entries */
042 NEVER_DEREF_ALIASES( 0, "never" ),
043
044 /** Alias handling mode value that dereferences only when searching */
045 DEREF_IN_SEARCHING( 1, "searching" ),
046
047 /** Alias handling mode value that dereferences only in finding the base */
048 DEREF_FINDING_BASE_OBJ( 2, "finding" ),
049
050 /** Alias handling mode value that dereferences always */
051 DEREF_ALWAYS( 3, "always" );
052
053
054 /** Stores the integer value of each element of the enumeration */
055 private int value;
056 /** Stores the integer value of each element of the enumeration */
057 private String jndiValue;
058
059
060 /**
061 * Private constructor so no other instances can be created other than the
062 * public static constants in this class.
063 *
064 * @param value the integer value of the enumeration.
065 */
066 private AliasDerefMode( int value, String jndiValue )
067 {
068 this.value = value;
069 this.jndiValue = jndiValue;
070 }
071
072
073 /**
074 * @return The value associated with the current element.
075 */
076 public int getValue()
077 {
078 return value;
079 }
080
081 /**
082 * Gets the enumeration from by extracting the value for the JNDI LDAP
083 * specific environment property, java.naming.ldap.derefAliases, from the
084 * environment.
085 *
086 * @param env
087 * the JNDI environment with a potential value for the
088 * java.naming.ldap.derefAliases property
089 * @return the enumeration for the environment
090 */
091 public static AliasDerefMode getEnum( Map<String, Object> env )
092 {
093 String property = ( String ) env.get( JndiPropertyConstants.JNDI_LDAP_DAP_DEREF_ALIASES );
094
095 if ( null == property )
096 {
097 return DEREF_ALWAYS;
098 }
099 else
100 {
101 if ( property.trim().equalsIgnoreCase( "always" ) )
102 {
103 return DEREF_ALWAYS;
104 }
105 else if ( property.trim().equalsIgnoreCase( "never" ) )
106 {
107 return NEVER_DEREF_ALIASES;
108 }
109 else if ( property.trim().equalsIgnoreCase( "finding" ) )
110 {
111 return DEREF_FINDING_BASE_OBJ;
112 }
113 else if ( property.trim().equalsIgnoreCase( "searching" ) )
114 {
115 return DEREF_IN_SEARCHING;
116 }
117 else
118 {
119 throw new IllegalArgumentException( I18n.err( I18n.ERR_04186, property,
120 JndiPropertyConstants.JNDI_LDAP_DAP_DEREF_ALIASES ) );
121 }
122 }
123 }
124
125 /**
126 * Checks to see if we dereference while searching and finding the base.
127 *
128 * @return true if value is DEREF_ALWAYS, false otherwise
129 */
130 public boolean isDerefAlways()
131 {
132 return this == DEREF_ALWAYS;
133 }
134
135
136 /**
137 * Checks to see if we never dereference aliases.
138 *
139 * @return true if value is NEVER_DEREF_ALIASES, false otherwise
140 */
141 public boolean isNeverDeref()
142 {
143 return this == NEVER_DEREF_ALIASES;
144 }
145
146
147 /**
148 * Checks to see if we dereference while searching.
149 *
150 * @return true if value is DEREF_ALWAYS_VAL, or DEREF_IN_SEARCHING, and
151 * false otherwise.
152 */
153 public boolean isDerefInSearching()
154 {
155 switch ( this )
156 {
157 case DEREF_ALWAYS :
158 return true;
159
160 case DEREF_FINDING_BASE_OBJ :
161 return false;
162
163 case DEREF_IN_SEARCHING :
164 return true;
165
166 case NEVER_DEREF_ALIASES :
167 return false;
168
169 default:
170 throw new IllegalArgumentException( I18n.err( I18n.ERR_04187 ) );
171 }
172 }
173
174
175 /**
176 * Checks to see if we dereference while finding the base.
177 *
178 * @return true if value is DEREF_ALWAYS, or DEREF_FINDING_BASE_OBJ, and
179 * false otherwise.
180 */
181 public boolean isDerefFindingBase()
182 {
183 switch ( this )
184 {
185 case DEREF_ALWAYS :
186 return true;
187
188 case DEREF_FINDING_BASE_OBJ :
189 return true;
190
191 case DEREF_IN_SEARCHING :
192 return false;
193
194 case NEVER_DEREF_ALIASES :
195 return false;
196
197 default:
198 throw new IllegalArgumentException( "Class has bug: check for valid enumeration values" );
199 }
200 }
201
202
203 public String getJndiValue()
204 {
205 return jndiValue;
206 }
207 }