Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * Copyright (C) 2006 The Guava Authors
   *
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
 
 package com.google.common.base;
 
Utility class for converting between various ASCII case formats.

Author(s):
Mike Bostock
Since:
1.0
 
 public enum CaseFormat {
  
Hyphenated variable naming convention, e.g., "lower-hyphen".
 
   LOWER_HYPHEN(CharMatcher.is('-'), "-"),

  
C++ variable naming convention, e.g., "lower_underscore".
 
   LOWER_UNDERSCORE(CharMatcher.is('_'), "_"),

  
Java variable naming convention, e.g., "lowerCamel".
 
   LOWER_CAMEL(CharMatcher.inRange('A''Z'), ""),

  
Java and C++ class naming convention, e.g., "UpperCamel".
 
   UPPER_CAMEL(CharMatcher.inRange('A''Z'), ""),

  
Java and C++ constant naming convention, e.g., "UPPER_UNDERSCORE".
 
   UPPER_UNDERSCORE(CharMatcher.is('_'), "_");
 
   private final CharMatcher wordBoundary;
   private final String wordSeparator;
 
   CaseFormat(CharMatcher wordBoundaryString wordSeparator) {
     this. = wordBoundary;
     this. = wordSeparator;
   }

  
Converts the specified String s from this format to the specified format. A "best effort" approach is taken; if s does not conform to the assumed format, then the behavior of this method is undefined but we make a reasonable effort at converting anyway.
 
   public String to(CaseFormat formatString s) {
     if (format == null) {
       throw new NullPointerException();
     }
     if (s == null) {
       throw new NullPointerException();
     }
 
     if (format == this) {
       return s;
     }
 
     /* optimize cases where no camel conversion is required */
     switch (this) {
       case :
         switch (format) {
           case :
             return s.replace('-''_');
           case :
             return Ascii.toUpperCase(s.replace('-''_'));
         }
         break;
       case :
         switch (format) {
           case :
             return s.replace('_''-');
           case :
             return Ascii.toUpperCase(s);
         }
         break;
       case :
         switch (format) {
           case :
            return Ascii.toLowerCase(s.replace('_''-'));
          case :
            return Ascii.toLowerCase(s);
        }
        break;
    }
    // otherwise, deal with camel conversion
    StringBuilder out = null;
    int i = 0;
    int j = -1;
    while ((j = .indexIn(s, ++j)) != -1) {
      if (i == 0) {
        // include some extra space for separators
        out = new StringBuilder(s.length() + 4 * .length());
        out.append(format.normalizeFirstWord(s.substring(ij)));
      } else {
        out.append(format.normalizeWord(s.substring(ij)));
      }
      out.append(format.wordSeparator);
      i = j + .length();
    }
    if (i == 0) {
      return format.normalizeFirstWord(s);
    }
    out.append(format.normalizeWord(s.substring(i)));
    return out.toString();
  }
  private String normalizeFirstWord(String word) {
    switch (this) {
      case :
        return Ascii.toLowerCase(word);
      default:
        return normalizeWord(word);
    }
  }
  private String normalizeWord(String word) {
    switch (this) {
      case :
        return Ascii.toLowerCase(word);
      case :
        return Ascii.toLowerCase(word);
      case :
        return firstCharOnlyToUpper(word);
      case :
        return firstCharOnlyToUpper(word);
      case :
        return Ascii.toUpperCase(word);
    }
    throw new RuntimeException("unknown case: " + this);
  }
  private static String firstCharOnlyToUpper(String word) {
    int length = word.length();
    if (length == 0) {
      return word;
    }
    return new StringBuilder(length)
        .append(Ascii.toUpperCase(word.charAt(0)))
        .append(Ascii.toLowerCase(word.substring(1)))
        .toString();
  }
New to GrepCode? Check out our FAQ X