1. /*

  2.  * Copyright 2001-2004 The Apache Software Foundation.

  3.  * 

  4.  * Licensed under the Apache License, Version 2.0 (the "License");

  5.  * you may not use this file except in compliance with the License.

  6.  * You may obtain a copy of the License at

  7.  * 

  8.  *      http://www.apache.org/licenses/LICENSE-2.0

  9.  * 

  10.  * Unless required by applicable law or agreed to in writing, software

  11.  * distributed under the License is distributed on an "AS IS" BASIS,

  12.  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

  13.  * See the License for the specific language governing permissions and

  14.  * limitations under the License.

  15.  */ 

  16. 

  17. package org.apache.commons.codec.language;

  18. 

  19. import org.apache.commons.codec.EncoderException;

  20. import org.apache.commons.codec.StringEncoder;

  21. 

  22. /**

  23.  * Encodes a string into a double metaphone value.

  24.  * This Implementation is based on the algorithm by <CITE>Lawrence Philips</CITE>.

  25.  * <ul>

  26.  * <li>Original Article: <a 

  27.  * href="http://www.cuj.com/documents/s=8038/cuj0006philips/">

  28.  * http://www.cuj.com/documents/s=8038/cuj0006philips/</a></li>

  29.  * <li>Original Source Code: <a href="ftp://ftp.cuj.com/pub/2000/1806/philips.zip">

  30.  * ftp://ftp.cuj.com/pub/2000/1806/philips.zip</a></li>

  31.  * </ul>

  32.  * 

  33.  * @author Apache Software Foundation

  34.  * @version $Id: DoubleMetaphone.java,v 1.24 2004/06/05 18:32:04 ggregory Exp $

  35.  */

  36. public class DoubleMetaphone implements StringEncoder {

  37. 

  38.     /**

  39.      * "Vowels" to test for

  40.      */

  41.     private static final String VOWELS = "AEIOUY";

  42. 

  43.     /**

  44.      * Prefixes when present which are not pronounced

  45.      */

  46.     private static final String[] SILENT_START = 

  47.     { "GN", "KN", "PN", "WR", "PS" };

  48.     private static final String[] L_R_N_M_B_H_F_V_W_SPACE = 

  49.     { "L", "R", "N", "M", "B", "H", "F", "V", "W", " " };

  50.     private static final String[] ES_EP_EB_EL_EY_IB_IL_IN_IE_EI_ER = 

  51.     { "ES", "EP", "EB", "EL", "EY", "IB", "IL", "IN", "IE", "EI", "ER" };

  52.     private static final String[] L_T_K_S_N_M_B_Z = 

  53.     { "L", "T", "K", "S", "N", "M", "B", "Z" };

  54. 

  55.     /**

  56.      * Maximum length of an encoding, default is 4

  57.      */

  58.     protected int maxCodeLen = 4;

  59. 

  60.     /**

  61.      * Creates an instance of this DoubleMetaphone encoder

  62.      */

  63.     public DoubleMetaphone() {

  64.         super();

  65.     }

  66.     

  67.     /**

  68.      * Encode a value with Double Metaphone

  69.      *

  70.      * @param value String to encode

  71.      * @return an encoded string

  72.      */

  73.     public String doubleMetaphone(String value) {

  74.         return doubleMetaphone(value, false);

  75.     }

  76.     

  77.     /**

  78.      * Encode a value with Double Metaphone, optionally using the alternate

  79.      * encoding.

  80.      *

  81.      * @param value String to encode

  82.      * @param alternate use alternate encode

  83.      * @return an encoded string

  84.      */

  85.     public String doubleMetaphone(String value, boolean alternate) {

  86.         value = cleanInput(value);

  87.         if (value == null) {

  88.             return null;

  89.         }

  90.         

  91.         boolean slavoGermanic = isSlavoGermanic(value);

  92.         int index = isSilentStart(value) ? 1 : 0;

  93.         

  94.         DoubleMetaphoneResult result = new DoubleMetaphoneResult(this.getMaxCodeLen());

  95.         

  96.         while (!result.isComplete() && index <= value.length() - 1) {

  97.             switch (value.charAt(index)) {

  98.             case 'A':

  99.             case 'E':

  100.             case 'I':

  101.             case 'O':

  102.             case 'U':

  103.             case 'Y':

  104.                 index = handleAEIOUY(value, result, index);

  105.                 break;

  106.             case 'B':

  107.                 result.append('P');

  108.                 index = charAt(value, index + 1) == 'B' ? index + 2 : index + 1;

  109.                 break;

  110.             case '\u00C7':

  111.                 // A C with a Cedilla

  112.                 result.append('S');

  113.                 index++;

  114.                 break; 

  115.             case 'C':

  116.                 index = handleC(value, result, index);

  117.                 break;

  118.             case 'D':

  119.                 index = handleD(value, result, index);

  120.                 break;

  121.             case 'F':

  122.                 result.append('F');

  123.                 index = charAt(value, index + 1) == 'F' ? index + 2 : index + 1;

  124.                 break;

  125.             case 'G':

  126.                 index = handleG(value, result, index, slavoGermanic);

  127.                 break;

  128.             case 'H':

  129.                 index = handleH(value, result, index);

  130.                 break;

  131.             case 'J':

  132.                 index = handleJ(value, result, index, slavoGermanic);

  133.                 break;

  134.             case 'K':

  135.                 result.append('K');

  136.                 index = charAt(value, index + 1) == 'K' ? index + 2 : index + 1;

  137.                 break;

  138.             case 'L':

  139.                 index = handleL(value, result, index);

  140.                 break;

  141.             case 'M':

  142.                 result.append('M');

  143.                 index = conditionM0(value, index) ? index + 2 : index + 1;

  144.                 break;

  145.             case 'N':

  146.                 result.append('N');

  147.                 index = charAt(value, index + 1) == 'N' ? index + 2 : index + 1;

  148.                 break;

  149.             case '\u00D1':

  150.                 // N with a tilde (spanish ene)

  151.                 result.append('N');

  152.                 index++;

  153.                 break;

  154.             case 'P':

  155.                 index = handleP(value, result, index);

  156.                 break;

  157.             case 'Q':

  158.                 result.append('K');

  159.                 index = charAt(value, index + 1) == 'Q' ? index + 2 : index + 1;

  160.                 break;

  161.             case 'R':

  162.                 index = handleR(value, result, index, slavoGermanic);

  163.                 break;

  164.             case 'S':

  165.                 index = handleS(value, result, index, slavoGermanic);

  166.                 break;

  167.             case 'T':

  168.                 index = handleT(value, result, index);

  169.                 break;

  170.             case 'V':

  171.                 result.append('F');

  172.                 index = charAt(value, index + 1) == 'V' ? index + 2 : index + 1;

  173.                 break;

  174.             case 'W':

  175.                 index = handleW(value, result, index);

  176.                 break;

  177.             case 'X':

  178.                 index = handleX(value, result, index);

  179.                 break;

  180.             case 'Z':

  181.                 index = handleZ(value, result, index, slavoGermanic);

  182.                 break;

  183.             default:

  184.                 index++;

  185.                 break;

  186.             }

  187.         }

  188. 

  189.         return alternate ? result.getAlternate() : result.getPrimary();

  190.     }

  191.     

  192.     /**

  193.      * Encode the value using DoubleMetaphone.  It will only work if 

  194.      * <code>obj</code> is a <code>String</code> (like <code>Metaphone</code>).

  195.      *

  196.      * @param obj Object to encode (should be of type String)

  197.      * @return An encoded Object (will be of type String)

  198.      * @throws EncoderException encode parameter is not of type String

  199.      */

  200.     public Object encode(Object obj) throws EncoderException {

  201.         if (!(obj instanceof String)) {

  202.             throw new EncoderException("DoubleMetaphone encode parameter is not of type String"); 

  203.         } 

  204.         return doubleMetaphone((String) obj);

  205.     }

  206. 

  207.     /**

  208.      * Encode the value using DoubleMetaphone.

  209.      *

  210.      * @param value String to encode

  211.      * @return An encoded String

  212.      */

  213.     public String encode(String value) {

  214.         return doubleMetaphone(value);   

  215.     }

  216. 

  217.     /**

  218.      * Check if the Double Metaphone values of two <code>String</code> values

  219.      * are equal.

  220.      * 

  221.      * @param value1 The left-hand side of the encoded {@link String#equals(Object)}.

  222.      * @param value2 The right-hand side of the encoded {@link String#equals(Object)}.

  223.      * @return <code>true</code> if the encoded <code>String</code>s are equal;

  224.      *          <code>false</code> otherwise.

  225.      * @see #isDoubleMetaphoneEqual(String,String,boolean)

  226.      */

  227.     public boolean isDoubleMetaphoneEqual(String value1, String value2) {

  228.         return isDoubleMetaphoneEqual(value1, value2, false);

  229.     }

  230.     

  231.     /**

  232.      * Check if the Double Metaphone values of two <code>String</code> values

  233.      * are equal, optionally using the alternate value.

  234.      * 

  235.      * @param value1 The left-hand side of the encoded {@link String#equals(Object)}.

  236.      * @param value2 The right-hand side of the encoded {@link String#equals(Object)}.

  237.      * @param alternate use the alternate value if <code>true</code>.

  238.      * @return <code>true</code> if the encoded <code>String</code>s are equal;

  239.      *          <code>false</code> otherwise.

  240.      */

  241.     public boolean isDoubleMetaphoneEqual(String value1, 

  242.                                           String value2, 

  243.                                           boolean alternate) {

  244.         return doubleMetaphone(value1, alternate).equals(doubleMetaphone

  245.                                                          (value2, alternate));

  246.     }

  247.     

  248.     /**

  249.      * Returns the maxCodeLen.

  250.      * @return int

  251.      */

  252.     public int getMaxCodeLen() {

  253.         return this.maxCodeLen;

  254.     }

  255. 

  256.     /**

  257.      * Sets the maxCodeLen.

  258.      * @param maxCodeLen The maxCodeLen to set

  259.      */

  260.     public void setMaxCodeLen(int maxCodeLen) {

  261.         this.maxCodeLen = maxCodeLen;

  262.     }

  263. 

  264.     //-- BEGIN HANDLERS --//

  265. 

  266.     /**

  267.      * Handles 'A', 'E', 'I', 'O', 'U', and 'Y' cases

  268.      */

  269.     private int handleAEIOUY(String value, DoubleMetaphoneResult result, int 

  270.                              index) {

  271.         if (index == 0) {

  272.             result.append('A');

  273.         }

  274.         return index + 1;

  275.     }

  276.     

  277.     /**

  278.      * Handles 'C' cases

  279.      */

  280.     private int handleC(String value, 

  281.                         DoubleMetaphoneResult result, 

  282.                         int index) {

  283.         if (conditionC0(value, index)) {  // very confusing, moved out

  284.             result.append('K');

  285.             index += 2;

  286.         } else if (index == 0 && contains(value, index, 6, "CAESAR")) {

  287.             result.append('S');

  288.             index += 2;

  289.         } else if (contains(value, index, 2, "CH")) {

  290.             index = handleCH(value, result, index);

  291.         } else if (contains(value, index, 2, "CZ") && 

  292.                    !contains(value, index - 2, 4, "WICZ")) {

  293.             //-- "Czerny" --//

  294.             result.append('S', 'X');

  295.             index += 2;

  296.         } else if (contains(value, index + 1, 3, "CIA")) {

  297.             //-- "focaccia" --//

  298.             result.append('X');

  299.             index += 3;

  300.         } else if (contains(value, index, 2, "CC") && 

  301.                    !(index == 1 && charAt(value, 0) == 'M')) {

  302.             //-- double "cc" but not "McClelland" --//

  303.             return handleCC(value, result, index);

  304.         } else if (contains(value, index, 2, "CK", "CG", "CQ")) {

  305.             result.append('K');

  306.             index += 2;

  307.         } else if (contains(value, index, 2, "CI", "CE", "CY")) {

  308.             //-- Italian vs. English --//

  309.             if (contains(value, index, 3, "CIO", "CIE", "CIA")) {

  310.                 result.append('S', 'X');

  311.             } else {

  312.                 result.append('S');

  313.             }

  314.             index += 2;

  315.         } else {

  316.             result.append('K');

  317.             if (contains(value, index + 1, 2, " C", " Q", " G")) { 

  318.                 //-- Mac Caffrey, Mac Gregor --//

  319.                 index += 3;

  320.             } else if (contains(value, index + 1, 1, "C", "K", "Q") && 

  321.                        !contains(value, index + 1, 2, "CE", "CI")) {

  322.                 index += 2;

  323.             } else {

  324.                 index++;

  325.             }

  326.         }

  327.         

  328.         return index;

  329.     }

  330. 

  331.     /**

  332.      * Handles 'CC' cases

  333.      */

  334.     private int handleCC(String value, 

  335.                          DoubleMetaphoneResult result, 

  336.                          int index) {

  337.         if (contains(value, index + 2, 1, "I", "E", "H") && 

  338.             !contains(value, index + 2, 2, "HU")) {

  339.             //-- "bellocchio" but not "bacchus" --//

  340.             if ((index == 1 && charAt(value, index - 1) == 'A') || 

  341.                 contains(value, index - 1, 5, "UCCEE", "UCCES")) {

  342.                 //-- "accident", "accede", "succeed" --//

  343.                 result.append("KS");

  344.             } else {

  345.                 //-- "bacci", "bertucci", other Italian --//

  346.                 result.append('X');

  347.             }

  348.             index += 3;

  349.         } else {    // Pierce's rule

  350.             result.append('K');

  351.             index += 2;

  352.         }

  353.         

  354.         return index;

  355.     }

  356.     

  357.     /**

  358.      * Handles 'CH' cases

  359.      */

  360.     private int handleCH(String value, 

  361.                          DoubleMetaphoneResult result, 

  362.                          int index) {

  363.         if (index > 0 && contains(value, index, 4, "CHAE")) {   // Michael

  364.             result.append('K', 'X');

  365.             return index + 2;

  366.         } else if (conditionCH0(value, index)) {

  367.             //-- Greek roots ("chemistry", "chorus", etc.) --//

  368.             result.append('K');

  369.             return index + 2;

  370.         } else if (conditionCH1(value, index)) {

  371.             //-- Germanic, Greek, or otherwise 'ch' for 'kh' sound --//

  372.             result.append('K');

  373.             return index + 2;

  374.         } else {

  375.             if (index > 0) {

  376.                 if (contains(value, 0, 2, "MC")) {

  377.                     result.append('K');

  378.                 } else {

  379.                     result.append('X', 'K');

  380.                 }

  381.             } else {

  382.                 result.append('X');

  383.             }

  384.             return index + 2;

  385.         }

  386.     }

  387. 

  388.     /**

  389.      * Handles 'D' cases

  390.      */

  391.     private int handleD(String value, 

  392.                         DoubleMetaphoneResult result, 

  393.                         int index) {

  394.         if (contains(value, index, 2, "DG")) {

  395.             //-- "Edge" --//

  396.             if (contains(value, index + 2, 1, "I", "E", "Y")) {

  397.                 result.append('J');

  398.                 index += 3;

  399.                 //-- "Edgar" --//

  400.             } else {

  401.                 result.append("TK");

  402.                 index += 2;

  403.             }

  404.         } else if (contains(value, index, 2, "DT", "DD")) {

  405.             result.append('T');

  406.             index += 2;

  407.         } else {

  408.             result.append('T');

  409.             index++;

  410.         }

  411.         return index;

  412.     }

  413. 

  414.     /**

  415.      * Handles 'G' cases

  416.      */

  417.     private int handleG(String value, 

  418.                         DoubleMetaphoneResult result, 

  419.                         int index, 

  420.                         boolean slavoGermanic) {

  421.         if (charAt(value, index + 1) == 'H') {

  422.             index = handleGH(value, result, index);

  423.         } else if (charAt(value, index + 1) == 'N') {

  424.             if (index == 1 && isVowel(charAt(value, 0)) && !slavoGermanic) {

  425.                 result.append("KN", "N");

  426.             } else if (!contains(value, index + 2, 2, "EY") && 

  427.                        charAt(value, index + 1) != 'Y' && !slavoGermanic) {

  428.                 result.append("N", "KN");

  429.             } else {

  430.                 result.append("KN");

  431.             }

  432.             index = index + 2;

  433.         } else if (contains(value, index + 1, 2, "LI") && !slavoGermanic) {

  434.             result.append("KL", "L");

  435.             index += 2;

  436.         } else if (index == 0 && (charAt(value, index + 1) == 'Y' || contains(value, index + 1, 2, ES_EP_EB_EL_EY_IB_IL_IN_IE_EI_ER))) {

  437.             //-- -ges-, -gep-, -gel-, -gie- at beginning --//

  438.             result.append('K', 'J');

  439.             index += 2;

  440.         } else if ((contains(value, index + 1, 2, "ER") || 

  441.                     charAt(value, index + 1) == 'Y') &&

  442.                    !contains(value, 0, 6, "DANGER", "RANGER", "MANGER") &&

  443.                    !contains(value, index - 1, 1, "E", "I") && 

  444.                    !contains(value, index - 1, 3, "RGY", "OGY")) {

  445.             //-- -ger-, -gy- --//

  446.             result.append('K', 'J');

  447.             index += 2;

  448.         } else if (contains(value, index + 1, 1, "E", "I", "Y") || 

  449.                    contains(value, index - 1, 4, "AGGI", "OGGI")) {

  450.             //-- Italian "biaggi" --//

  451.             if ((contains(value, 0 ,4, "VAN ", "VON ") || contains(value, 0, 3, "SCH")) || contains(value, index + 1, 2, "ET")) {

  452.                 //-- obvious germanic --//

  453.                 result.append('K');

  454.             } else if (contains(value, index + 1, 4, "IER")) {

  455.                 result.append('J');

  456.             } else {

  457.                 result.append('J', 'K');

  458.             }

  459.             index += 2;

  460.         } else if (charAt(value, index + 1) == 'G') {

  461.             index += 2;

  462.             result.append('K');

  463.         } else {

  464.             index++;

  465.             result.append('K');

  466.         }

  467.         return index;

  468.     }

  469.     

  470.     /**

  471.      * Handles 'GH' cases

  472.      */

  473.     private int handleGH(String value, 

  474.                          DoubleMetaphoneResult result, 

  475.                          int index) {

  476.         if (index > 0 && !isVowel(charAt(value, index - 1))) {

  477.             result.append('K');

  478.             index += 2;

  479.         } else if (index == 0) {

  480.             if (charAt(value, index + 2) == 'I') {

  481.                 result.append('J');

  482.             } else {

  483.                 result.append('K');

  484.             }

  485.             index += 2;

  486.         } else if ((index > 1 && contains(value, index - 2, 1, "B", "H", "D")) ||

  487.                    (index > 2 && contains(value, index - 3, 1, "B", "H", "D")) ||

  488.                    (index > 3 && contains(value, index - 4, 1, "B", "H"))) {

  489.             //-- Parker's rule (with some further refinements) - "hugh"

  490.             index += 2;

  491.         } else {

  492.             if (index > 2 && charAt(value, index - 1) == 'U' && 

  493.                 contains(value, index - 3, 1, "C", "G", "L", "R", "T")) {

  494.                 //-- "laugh", "McLaughlin", "cough", "gough", "rough", "tough"

  495.                 result.append('F');

  496.             } else if (index > 0 && charAt(value, index - 1) != 'I') {

  497.                 result.append('K');

  498.             }

  499.             index += 2;

  500.         }

  501.         return index;

  502.     }

  503. 

  504.     /**

  505.      * Handles 'H' cases

  506.      */

  507.     private int handleH(String value, 

  508.                         DoubleMetaphoneResult result, 

  509.                         int index) {

  510.         //-- only keep if first & before vowel or between 2 vowels --//

  511.         if ((index == 0 || isVowel(charAt(value, index - 1))) && 

  512.             isVowel(charAt(value, index + 1))) {

  513.             result.append('H');

  514.             index += 2;

  515.             //-- also takes car of "HH" --//

  516.         } else {

  517.             index++;

  518.         }

  519.         return index;

  520.     }

  521.     

  522.     /**

  523.      * Handles 'J' cases

  524.      */

  525.     private int handleJ(String value, DoubleMetaphoneResult result, int index, 

  526.                         boolean slavoGermanic) {

  527.         if (contains(value, index, 4, "JOSE") || contains(value, 0, 4, "SAN ")) {

  528.                 //-- obvious Spanish, "Jose", "San Jacinto" --//

  529.                 if ((index == 0 && (charAt(value, index + 4) == ' ') || 

  530.                      value.length() == 4) || contains(value, 0, 4, "SAN ")) {

  531.                     result.append('H');

  532.                 } else {

  533.                     result.append('J', 'H');

  534.                 }

  535.                 index++;

  536.             } else {

  537.                 if (index == 0 && !contains(value, index, 4, "JOSE")) {

  538.                     result.append('J', 'A');

  539.                 } else if (isVowel(charAt(value, index - 1)) && !slavoGermanic && 

  540.                               (charAt(value, index + 1) == 'A' || charAt(value, index + 1) == 'O')) {

  541.                     result.append('J', 'H');

  542.                 } else if (index == value.length() - 1) {

  543.                     result.append('J', ' ');

  544.                 } else if (!contains(value, index + 1, 1, L_T_K_S_N_M_B_Z) && !contains(value, index - 1, 1, "S", "K", "L")) {

  545.                     result.append('J');

  546.                 }

  547. 

  548.                 if (charAt(value, index + 1) == 'J') {

  549.                     index += 2;

  550.                 } else {

  551.                     index++;

  552.                 }

  553.             }

  554.         return index;

  555.     }

  556.     

  557.     /**

  558.      * Handles 'L' cases

  559.      */

  560.     private int handleL(String value, 

  561.                         DoubleMetaphoneResult result, 

  562.                         int index) {

  563.         result.append('L');

  564.         if (charAt(value, index + 1) == 'L') {

  565.             if (conditionL0(value, index)) {

  566.                 result.appendAlternate(' ');

  567.             }

  568.             index += 2;

  569.         } else {

  570.             index++;

  571.         }

  572.         return index;

  573.     }

  574. 

  575.     /**

  576.      * Handles 'P' cases

  577.      */

  578.     private int handleP(String value, 

  579.                         DoubleMetaphoneResult result, 

  580.                         int index) {

  581.         if (charAt(value, index + 1) == 'H') {

  582.             result.append('F');

  583.             index += 2;

  584.         } else {

  585.             result.append('P');

  586.             index = contains(value, index + 1, 1, "P", "B") ? index + 2 : index + 1;

  587.         }

  588.         return index;

  589.     }

  590. 

  591.     /**

  592.      * Handles 'R' cases

  593.      */

  594.     private int handleR(String value, 

  595.                         DoubleMetaphoneResult result, 

  596.                         int index, 

  597.                         boolean slavoGermanic) {

  598.         if (index == value.length() - 1 && !slavoGermanic && 

  599.             contains(value, index - 2, 2, "IE") && 

  600.             !contains(value, index - 4, 2, "ME", "MA")) {

  601.             result.appendAlternate('R');

  602.         } else {

  603.             result.append('R');

  604.         }

  605.         return charAt(value, index + 1) == 'R' ? index + 2 : index + 1;

  606.     }

  607. 

  608.     /**

  609.      * Handles 'S' cases

  610.      */

  611.     private int handleS(String value, 

  612.                         DoubleMetaphoneResult result, 

  613.                         int index, 

  614.                         boolean slavoGermanic) {

  615.         if (contains(value, index - 1, 3, "ISL", "YSL")) {

  616.             //-- special cases "island", "isle", "carlisle", "carlysle" --//

  617.             index++;

  618.         } else if (index == 0 && contains(value, index, 5, "SUGAR")) {

  619.             //-- special case "sugar-" --//

  620.             result.append('X', 'S');

  621.             index++;

  622.         } else if (contains(value, index, 2, "SH")) {

  623.             if (contains(value, index + 1, 4, 

  624.                          "HEIM", "HOEK", "HOLM", "HOLZ")) {

  625.                 //-- germanic --//

  626.                 result.append('S');

  627.             } else {

  628.                 result.append('X');

  629.             }

  630.             index += 2;

  631.         } else if (contains(value, index, 3, "SIO", "SIA") || contains(value, index, 4, "SIAN")) {

  632.             //-- Italian and Armenian --//

  633.             if (slavoGermanic) {

  634.                 result.append('S');

  635.             } else {

  636.                 result.append('S', 'X');

  637.             }

  638.             index += 3;

  639.         } else if ((index == 0 && contains(value, index + 1, 1, "M", "N", "L", "W")) || contains(value, index + 1, 1, "Z")) {

  640.             //-- german & anglicisations, e.g. "smith" match "schmidt" //

  641.             // "snider" match "schneider" --//

  642.             //-- also, -sz- in slavic language altho in hungarian it //

  643.             //   is pronounced "s" --//

  644.             result.append('S', 'X');

  645.             index = contains(value, index + 1, 1, "Z") ? index + 2 : index + 1;

  646.         } else if (contains(value, index, 2, "SC")) {

  647.             index = handleSC(value, result, index);

  648.         } else {

  649.             if (index == value.length() - 1 && contains(value, index - 2, 

  650.                                                         2, "AI", "OI")){

  651.                 //-- french e.g. "resnais", "artois" --//

  652.                 result.appendAlternate('S');

  653.             } else {

  654.                 result.append('S');

  655.             }

  656.             index = contains(value, index + 1, 1, "S", "Z") ? index + 2 : index + 1;

  657.         }

  658.         return index;

  659.     }

  660. 

  661.     /**

  662.      * Handles 'SC' cases

  663.      */

  664.     private int handleSC(String value, 

  665.                          DoubleMetaphoneResult result, 

  666.                          int index) {

  667.         if (charAt(value, index + 2) == 'H') {

  668.             //-- Schlesinger's rule --//

  669.             if (contains(value, index + 3, 

  670.                          2, "OO", "ER", "EN", "UY", "ED", "EM")) {

  671.                 //-- Dutch origin, e.g. "school", "schooner" --//

  672.                 if (contains(value, index + 3, 2, "ER", "EN")) {

  673.                     //-- "schermerhorn", "schenker" --//

  674.                     result.append("X", "SK");

  675.                 } else {

  676.                     result.append("SK");

  677.                 }

  678.             } else {

  679.                 if (index == 0 && !isVowel(charAt(value, 3)) && charAt(value, 3) != 'W') {

  680.                     result.append('X', 'S');

  681.                 } else {

  682.                     result.append('X');

  683.                 }

  684.             }

  685.         } else if (contains(value, index + 2, 1, "I", "E", "Y")) {

  686.             result.append('S');

  687.         } else {

  688.             result.append("SK");

  689.         }

  690.         return index + 3;

  691.     }

  692. 

  693.     /**

  694.      * Handles 'T' cases

  695.      */

  696.     private int handleT(String value, 

  697.                         DoubleMetaphoneResult result, 

  698.                         int index) {

  699.         if (contains(value, index, 4, "TION")) {

  700.             result.append('X');

  701.             index += 3;

  702.         } else if (contains(value, index, 3, "TIA", "TCH")) {

  703.             result.append('X');

  704.             index += 3;

  705.         } else if (contains(value, index, 2, "TH") || contains(value, index, 

  706.                                                                3, "TTH")) {

  707.             if (contains(value, index + 2, 2, "OM", "AM") || 

  708.                 //-- special case "thomas", "thames" or germanic --//

  709.                 contains(value, 0, 4, "VAN ", "VON ") || 

  710.                 contains(value, 0, 3, "SCH")) {

  711.                 result.append('T');

  712.             } else {

  713.                 result.append('0', 'T');

  714.             }

  715.             index += 2;

  716.         } else {

  717.             result.append('T');

  718.             index = contains(value, index + 1, 1, "T", "D") ? index + 2 : index + 1;

  719.         }

  720.         return index;

  721.     }

  722. 

  723.     /**

  724.      * Handles 'W' cases

  725.      */

  726.     private int handleW(String value, 

  727.                         DoubleMetaphoneResult result, 

  728.                         int index) {

  729.         if (contains(value, index, 2, "WR")) {

  730.             //-- can also be in middle of word --//

  731.             result.append('R');

  732.             index += 2;

  733.         } else {

  734.             if (index == 0 && (isVowel(charAt(value, index + 1)) || 

  735.                                contains(value, index, 2, "WH"))) {

  736.                 if (isVowel(charAt(value, index + 1))) {

  737.                     //-- Wasserman should match Vasserman --//

  738.                     result.append('A', 'F');

  739.                 } else {

  740.                     //-- need Uomo to match Womo --//

  741.                     result.append('A');

  742.                 }

  743.                 index++;

  744.             } else if ((index == value.length() - 1 && isVowel(charAt(value, index - 1))) ||

  745.                        contains(value, index - 1, 

  746.                                 5, "EWSKI", "EWSKY", "OWSKI", "OWSKY") ||

  747.                        contains(value, 0, 3, "SCH")) {

  748.                 //-- Arnow should match Arnoff --//

  749.                 result.appendAlternate('F');

  750.                 index++;

  751.             } else if (contains(value, index, 4, "WICZ", "WITZ")) {

  752.                 //-- Polish e.g. "filipowicz" --//

  753.                 result.append("TS", "FX");

  754.                 index += 4;

  755.             } else {

  756.                 index++;

  757.             }

  758.         }

  759.         return index;

  760.     }

  761.     

  762.     /**

  763.      * Handles 'X' cases

  764.      */

  765.     private int handleX(String value, 

  766.                         DoubleMetaphoneResult result, 

  767.                         int index) {

  768.         if (index == 0) {

  769.             result.append('S');

  770.             index++;

  771.         } else {

  772.             if (!((index == value.length() - 1) && 

  773.                   (contains(value, index - 3, 3, "IAU", "EAU") || 

  774.                    contains(value, index - 2, 2, "AU", "OU")))) {

  775.                 //-- French e.g. breaux --//

  776.                 result.append("KS");

  777.             }

  778.             index = contains(value, index + 1, 1, "C", "X") ? index + 2 : index + 1;

  779.         }

  780.         return index;

  781.     }

  782. 

  783.     /**

  784.      * Handles 'Z' cases

  785.      */

  786.     private int handleZ(String value, DoubleMetaphoneResult result, int index, 

  787.                         boolean slavoGermanic) {

  788.         if (charAt(value, index + 1) == 'H') {

  789.             //-- Chinese pinyin e.g. "zhao" or Angelina "Zhang" --//

  790.             result.append('J');

  791.             index += 2;

  792.         } else {

  793.             if (contains(value, index + 1, 2, "ZO", "ZI", "ZA") || (slavoGermanic && (index > 0 && charAt(value, index - 1) != 'T'))) {

  794.                 result.append("S", "TS");

  795.             } else {

  796.                 result.append('S');

  797.             }

  798.             index = charAt(value, index + 1) == 'Z' ? index + 2 : index + 1;

  799.         }

  800.         return index;

  801.     }

  802. 

  803.     //-- BEGIN CONDITIONS --//

  804. 

  805.     /**

  806.      * Complex condition 0 for 'C'

  807.      */

  808.     private boolean conditionC0(String value, int index) {

  809. 		if (contains(value, index, 4, "CHIA")) {

  810. 			return true;

  811. 		} else if (index <= 1) {

  812. 			return false;

  813. 		} else if (isVowel(charAt(value, index - 2))) {

  814. 			return false;

  815. 		} else if (!contains(value, index - 1, 3, "ACH")) {

  816. 			return false;

  817. 		} else {

  818. 			char c = charAt(value, index + 2);

  819. 			return (c != 'I' && c != 'E')

  820. 					|| contains(value, index - 2, 6, "BACHER", "MACHER");

  821. 		}

  822. 	}

  823.     

  824.     /**

  825. 	 * Complex condition 0 for 'CH'

  826. 	 */

  827.     private boolean conditionCH0(String value, int index) {

  828.         if (index != 0) {

  829.             return false;

  830.         } else if (!contains(value, index + 1, 5, "HARAC", "HARIS") && 

  831.                    !contains(value, index + 1, 3, "HOR", "HYM", "HIA", "HEM")) {

  832.             return false;

  833.         } else if (contains(value, 0, 5, "CHORE")) {

  834.             return false;

  835.         } else {

  836.             return true;

  837.         }

  838.     }

  839.     

  840.     /**

  841.      * Complex condition 1 for 'CH'

  842.      */

  843.     private boolean conditionCH1(String value, int index) {

  844.         return ((contains(value, 0, 4, "VAN ", "VON ") || contains(value, 0, 

  845.                                                                    3, "SCH")) ||

  846.                 contains(value, index - 2, 6, "ORCHES", "ARCHIT", "ORCHID") ||

  847.                 contains(value, index + 2, 1, "T", "S") ||

  848.                 ((contains(value, index - 1, 1, "A", "O", "U", "E") || index == 0) &&

  849.                  (contains(value, index + 2, 1, L_R_N_M_B_H_F_V_W_SPACE) || index + 1 == value.length() - 1)));

  850.     }

  851.     

  852.     /**

  853.      * Complex condition 0 for 'L'

  854.      */

  855.     private boolean conditionL0(String value, int index) {

  856.         if (index == value.length() - 3 && 

  857.             contains(value, index - 1, 4, "ILLO", "ILLA", "ALLE")) {

  858.             return true;

  859.         } else if ((contains(value, index - 1, 2, "AS", "OS") || 

  860.                     contains(value, value.length() - 1, 1, "A", "O")) &&

  861.                    contains(value, index - 1, 4, "ALLE")) {

  862.             return true;

  863.         } else {

  864.             return false;

  865.         }

  866.     }

  867.     

  868.     /**

  869.      * Complex condition 0 for 'M'

  870.      */

  871.     private boolean conditionM0(String value, int index) {

  872. 		if (charAt(value, index + 1) == 'M') {

  873. 			return true;

  874. 		}

  875. 		return contains(value, index - 1, 3, "UMB")

  876. 				&& ((index + 1) == value.length() - 1 || contains(value,

  877. 						index + 2, 2, "ER"));

  878. 	}

  879.     

  880.     //-- BEGIN HELPER FUNCTIONS --//

  881. 

  882.     /**

  883. 	 * Determines whether or not a value is of slavo-germanic orgin. A value is

  884. 	 * of slavo-germanic origin if it contians any of 'W', 'K', 'CZ', or 'WITZ'.

  885. 	 */

  886.     private boolean isSlavoGermanic(String value) {

  887.         return value.indexOf('W') > -1 || value.indexOf('K') > -1 || 

  888.             value.indexOf("CZ") > -1 || value.indexOf("WITZ") > -1;

  889.     }

  890. 

  891.     /**

  892.      * Determines whether or not a character is a vowel or not

  893.      */

  894.     private boolean isVowel(char ch) {

  895.         return VOWELS.indexOf(ch) != -1;

  896.     }

  897. 

  898.     /**

  899.      * Determines whether or not the value starts with a silent letter.  It will

  900.      * return <code>true</code> if the value starts with any of 'GN', 'KN',

  901.      * 'PN', 'WR' or 'PS'.

  902.      */    

  903.     private boolean isSilentStart(String value) {

  904.         boolean result = false;

  905.         for (int i = 0; i < SILENT_START.length; i++) {

  906.             if (value.startsWith(SILENT_START[i])) {

  907.                 result = true;

  908.                 break;

  909.             }

  910.         }

  911.         return result;

  912.     }

  913. 

  914.     /**

  915.      * Cleans the input

  916.      */    

  917.     private String cleanInput(String input) {

  918. 		if (input == null) {

  919. 			return null;

  920. 		}

  921. 		input = input.trim();

  922. 		if (input.length() == 0) {

  923. 			return null;

  924. 		}

  925. 		return input.toUpperCase();

  926. 	}

  927. 

  928.     /**

  929. 	 * Gets the character at index <code>index</code> if available, otherwise

  930. 	 * it returns <code>Character.MIN_VALUE</code> so that there is some sort

  931. 	 * of a default

  932. 	 */    

  933.     protected char charAt(String value, int index) {

  934.         if (index < 0 || index >= value.length()) {

  935.             return Character.MIN_VALUE;

  936.         } 

  937.         return value.charAt(index);

  938.     }

  939. 

  940.     /**

  941.      * Shortcut method with 1 criteria

  942.      */    

  943.     private static boolean contains(String value, int start, int length, 

  944.                                     String criteria) {

  945.         return contains(value, start, length, 

  946.                         new String[] { criteria });

  947.     }

  948. 

  949.     /**

  950.      * Shortcut method with 2 criteria

  951.      */    

  952.     private static boolean contains(String value, int start, int length, 

  953.                                     String criteria1, String criteria2) {

  954.         return contains(value, start, length, 

  955.                         new String[] { criteria1, criteria2 });

  956.     }

  957. 

  958.     /**

  959.      * Shortcut method with 3 criteria

  960.      */    

  961.     private static boolean contains(String value, int start, int length, 

  962.                                     String criteria1, String criteria2, 

  963.                                     String criteria3) {

  964.         return contains(value, start, length, 

  965.                         new String[] { criteria1, criteria2, criteria3 });

  966.     }

  967. 

  968.     /**

  969.      * Shortcut method with 4 criteria

  970.      */    

  971.     private static boolean contains(String value, int start, int length, 

  972.                                     String criteria1, String criteria2, 

  973.                                     String criteria3, String criteria4) {

  974.         return contains(value, start, length, 

  975.                         new String[] { criteria1, criteria2, criteria3, 

  976.                                        criteria4 });

  977.     }

  978. 

  979.     /**

  980.      * Shortcut method with 5 criteria

  981.      */    

  982.     private static boolean contains(String value, int start, int length, 

  983.                                     String criteria1, String criteria2, 

  984.                                     String criteria3, String criteria4, 

  985.                                     String criteria5) {

  986.         return contains(value, start, length, 

  987.                         new String[] { criteria1, criteria2, criteria3, 

  988.                                        criteria4, criteria5 });

  989.     }

  990. 

  991.     /**

  992.      * Shortcut method with 6 criteria

  993.      */    

  994.     private static boolean contains(String value, int start, int length, 

  995.                                     String criteria1, String criteria2, 

  996.                                     String criteria3, String criteria4, 

  997.                                     String criteria5, String criteria6) {

  998.         return contains(value, start, length, 

  999.                         new String[] { criteria1, criteria2, criteria3, 

  1000.                                        criteria4, criteria5, criteria6 });

  1001.     }

  1002.     

  1003.     /**

  1004.      * Determines whether <code>value</code> contains any of the criteria 

  1005.      starting

  1006.      * at index <code>start</code> and matching up to length <code>length</code>

  1007.      */    

  1008.     protected static boolean contains(String value, int start, int length, 

  1009.                                       String[] criteria) {

  1010.         boolean result = false;

  1011.         if (start >= 0 && start + length <= value.length()) {

  1012.             String target = value.substring(start, start + length);

  1013. 

  1014.             for (int i = 0; i < criteria.length; i++) {

  1015.                 if (target.equals(criteria[i])) {

  1016.                     result = true;

  1017.                     break;

  1018.                 }

  1019.             }

  1020.         }

  1021.         return result;

  1022.     }

  1023.     

  1024.     //-- BEGIN INNER CLASSES --//

  1025.     

  1026.     /**

  1027.      * Inner class for storing results, since there is the optional alternate

  1028.      * encoding.

  1029.      */

  1030.     public class DoubleMetaphoneResult {

  1031. 

  1032.         private StringBuffer primary = new StringBuffer(getMaxCodeLen());

  1033.         private StringBuffer alternate = new StringBuffer(getMaxCodeLen());

  1034.         private int maxLength;

  1035. 

  1036.         public DoubleMetaphoneResult(int maxLength) {

  1037.             this.maxLength = maxLength;

  1038.         }

  1039. 

  1040.         public void append(char value) {

  1041.             appendPrimary(value);

  1042.             appendAlternate(value);

  1043.         }

  1044. 

  1045.         public void append(char primary, char alternate) {

  1046.             appendPrimary(primary);

  1047.             appendAlternate(alternate);

  1048.         }

  1049. 

  1050.         public void appendPrimary(char value) {

  1051.             if (this.primary.length() < this.maxLength) {

  1052.                 this.primary.append(value);

  1053.             }

  1054.         }

  1055. 

  1056.         public void appendAlternate(char value) {

  1057.             if (this.alternate.length() < this.maxLength) {

  1058.                 this.alternate.append(value);

  1059.             }

  1060.         }

  1061. 

  1062.         public void append(String value) {

  1063.             appendPrimary(value);

  1064.             appendAlternate(value);

  1065.         }

  1066. 

  1067.         public void append(String primary, String alternate) {

  1068.             appendPrimary(primary);

  1069.             appendAlternate(alternate);

  1070.         }

  1071. 

  1072.         public void appendPrimary(String value) {

  1073.             int addChars = this.maxLength - this.primary.length();

  1074.             if (value.length() <= addChars) {

  1075.                 this.primary.append(value);

  1076.             } else {

  1077.                 this.primary.append(value.substring(0, addChars));

  1078.             }

  1079.         }

  1080. 

  1081.         public void appendAlternate(String value) {

  1082.             int addChars = this.maxLength - this.alternate.length();

  1083.             if (value.length() <= addChars) {

  1084.                 this.alternate.append(value);

  1085.             } else {

  1086.                 this.alternate.append(value.substring(0, addChars));

  1087.             }

  1088.         }

  1089. 

  1090.         public String getPrimary() {

  1091.             return this.primary.toString();

  1092.         }

  1093. 

  1094.         public String getAlternate() {

  1095.             return this.alternate.toString();

  1096.         }

  1097. 

  1098.         public boolean isComplete() {

  1099.             return this.primary.length() >= this.maxLength && 

  1100.                 this.alternate.length() >= this.maxLength;

  1101.         }

  1102.     }

  1103. }