001    /*
002     * Copyright 2009-2015 UnboundID Corp.
003     * All Rights Reserved.
004     */
005    /*
006     * Copyright (C) 2009-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.migrate.ldapjdk;
022    
023    
024    
025    import com.unboundid.ldap.sdk.DN;
026    import com.unboundid.ldap.sdk.RDN;
027    import com.unboundid.util.NotMutable;
028    import com.unboundid.util.ThreadSafety;
029    import com.unboundid.util.ThreadSafetyLevel;
030    
031    import static com.unboundid.util.Debug.*;
032    import static com.unboundid.util.StaticUtils.*;
033    
034    
035    
036    /**
037     * This class provides a set of utility methods for working with LDAP DNs.
038     * <BR><BR>
039     * This class is primarily intended to be used in the process of updating
040     * applications which use the Netscape Directory SDK for Java to switch to or
041     * coexist with the UnboundID LDAP SDK for Java.  For applications not written
042     * using the Netscape Directory SDK for Java, the {@link DN} class should be
043     * used instead.
044     */
045    @NotMutable()
046    @ThreadSafety(level=ThreadSafetyLevel.COMPLETELY_THREADSAFE)
047    public final class LDAPDN
048    {
049      /**
050       * Prevent this class from being instantiated.
051       */
052      private LDAPDN()
053      {
054        // No implementation required.
055      }
056    
057    
058    
059      /**
060       * Retrieves a normalized representation of the provided DN.  If the provided
061       * string does not represent a valid distinguished name, then the value
062       * returned by this method will not be reliable.
063       *
064       * @param  dn  The string representation of the DN to be normalized.
065       *
066       * @return  A normalized representation of the provided DN.
067       */
068      public static String normalize(final String dn)
069      {
070        try
071        {
072          return DN.normalize(dn);
073        }
074        catch (Exception e)
075        {
076          debugException(e);
077          return toLowerCase(dn.trim());
078        }
079      }
080    
081    
082    
083      /**
084       * Explodes the provided DN into individual RDN components.  If the provided
085       * string does not represent a valid distinguished name, then the value
086       * returned by this method will not be reliable.
087       *
088       * @param  dn       The DN to be exploded into its RDN components.
089       * @param  noTypes  Indicates whether to exclude the attribute names and
090       *                  equal signs and only include the values of the RDN
091       *                  components.
092       *
093       * @return  An exploded representation of the provided DN.
094       */
095      public static String[] explodeDN(final String dn, final boolean noTypes)
096      {
097        try
098        {
099          final RDN[] rdns = new DN(dn).getRDNs();
100          final String[] rdnStrings = new String[rdns.length];
101          for (int i=0; i < rdns.length; i++)
102          {
103            if (noTypes)
104            {
105              final StringBuilder buffer = new StringBuilder();
106              for (final String s : rdns[i].getAttributeValues())
107              {
108                if (buffer.length() > 0)
109                {
110                  buffer.append('+');
111                }
112                buffer.append(s);
113              }
114              rdnStrings[i] = buffer.toString();
115            }
116            else
117            {
118              rdnStrings[i] = rdns[i].toString();
119            }
120          }
121          return rdnStrings;
122        }
123        catch (Exception e)
124        {
125          debugException(e);
126          return new String[] { dn };
127        }
128      }
129    
130    
131    
132      /**
133       * Explodes the provided RDN into individual name-value pairs.  If the
134       * provided string does not represent a valid relative distinguished name,
135       * then the value returned by this method will not be reliable.
136       *
137       * @param  rdn      The RDN to be exploded into its name-value pairs.
138       * @param  noTypes  Indicates whether to exclude the attribute names and
139       *                  equal signs and only include the values of the components.
140       *
141       * @return  An exploded representation of the provided DN.
142       */
143      public static String[] explodeRDN(final String rdn, final boolean noTypes)
144      {
145        try
146        {
147          final RDN      rdnObject  = new RDN(rdn);
148    
149          final String[] values = rdnObject.getAttributeValues();
150          if (noTypes)
151          {
152            return values;
153          }
154    
155          final String[] names      = rdnObject.getAttributeNames();
156          final String[] returnStrs = new String[names.length];
157    
158          for (int i=0; i < names.length; i++)
159          {
160            returnStrs[i] = names[i] + '=' + values[i];
161          }
162    
163          return returnStrs;
164        }
165        catch (Exception e)
166        {
167          debugException(e);
168          return new String[] { rdn };
169        }
170      }
171    
172    
173    
174      /**
175       * Indicates whether the provided strings represent the same distinguished
176       * name.
177       *
178       * @param  dn1  The first DN to be compared.
179       * @param  dn2  The second DN to be compared.
180       *
181       * @return  {@code true} if the provided strings represent the same
182       *          distinguished name, or {@code false} if not or if either of the
183       *          values cannot be parsed as a valid DN.
184       */
185      public static boolean equals(final String dn1, final String dn2)
186      {
187        try
188        {
189          return DN.equals(dn1, dn2);
190        }
191        catch (Exception e)
192        {
193          debugException(e);
194          return false;
195        }
196      }
197    }