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.ldap.constants.JndiPropertyConstants;
026
027
028 /**
029 * Type-safe derefAliases search parameter enumeration which determines the mode
030 * of alias handling. Note that the jndi values of these ValuedEnums correspond
031 * to the string value for the java.naming.ldap.derefAliases JNDI LDAP specific
032 * property. The integer value represents the values used in the LDAP ASN.1 for
033 * different settings.
034 *
035 * @author <a href="mailto:dev@directory.apache.org">Apache Directory Project</a>
036 * @version $Revision: 584670 $
037 */
038 public enum AliasDerefMode
039 {
040 /** Alias handling mode value that treats aliases like entries */
041 NEVER_DEREF_ALIASES( 0, "never" ),
042
043 /** Alias handling mode value that dereferences only when searching */
044 DEREF_IN_SEARCHING( 1, "searching" ),
045
046 /** Alias handling mode value that dereferences only in finding the base */
047 DEREF_FINDING_BASE_OBJ( 2, "finding" ),
048
049 /** Alias handling mode value that dereferences always */
050 DEREF_ALWAYS( 3, "always" );
051
052
053 /** Stores the integer value of each element of the enumeration */
054 private int value;
055 /** Stores the integer value of each element of the enumeration */
056 private String jndiValue;
057
058
059 /**
060 * Private constructor so no other instances can be created other than the
061 * public static constants in this class.
062 *
063 * @param value the integer value of the enumeration.
064 */
065 private AliasDerefMode( int value, String jndiValue )
066 {
067 this.value = value;
068 this.jndiValue = jndiValue;
069 }
070
071
072 /**
073 * @return The value associated with the current element.
074 */
075 public int getValue()
076 {
077 return value;
078 }
079
080 /**
081 * Gets the enumeration from by extracting the value for the JNDI LDAP
082 * specific environment property, java.naming.ldap.derefAliases, from the
083 * environment.
084 *
085 * @param env
086 * the JNDI environment with a potential value for the
087 * java.naming.ldap.derefAliases property
088 * @return the enumeration for the environment
089 */
090 public static AliasDerefMode getEnum( Map<String, Object> env )
091 {
092 String property = ( String ) env.get( JndiPropertyConstants.JNDI_LDAP_DAP_DEREF_ALIASES );
093
094 if ( null == property )
095 {
096 return DEREF_ALWAYS;
097 }
098 else
099 {
100 if ( property.trim().equalsIgnoreCase( "always" ) )
101 {
102 return DEREF_ALWAYS;
103 }
104 else if ( property.trim().equalsIgnoreCase( "never" ) )
105 {
106 return NEVER_DEREF_ALIASES;
107 }
108 else if ( property.trim().equalsIgnoreCase( "finding" ) )
109 {
110 return DEREF_FINDING_BASE_OBJ;
111 }
112 else if ( property.trim().equalsIgnoreCase( "searching" ) )
113 {
114 return DEREF_IN_SEARCHING;
115 }
116 else
117 {
118 throw new IllegalArgumentException( "Unrecogniced value '" + property + "' for "
119 + JndiPropertyConstants.JNDI_LDAP_DAP_DEREF_ALIASES + " JNDI property.\n"
120 + "Expected a value of either always, never, searching, or finding." );
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( "Class has bug: check for valid enumeration values" );
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 }