Clover coverage report - Code Coverage for hivemind release 1.1-beta-2
Coverage timestamp: Tue Jun 28 2005 10:28:23 EDT
file stats: LOC: 206   Methods: 6
NCLOC: 118   Classes: 1
 
 Source file Conditionals Statements Methods TOTAL
LocalizedNameGenerator.java 87.5% 92.2% 100% 91.5%
coverage coverage
 1    // Copyright 2004, 2005 The Apache Software Foundation
 2    //
 3    // Licensed under the Apache License, Version 2.0 (the "License");
 4    // you may not use this file except in compliance with the License.
 5    // You may obtain a copy of the License at
 6    //
 7    // http://www.apache.org/licenses/LICENSE-2.0
 8    //
 9    // Unless required by applicable law or agreed to in writing, software
 10    // distributed under the License is distributed on an "AS IS" BASIS,
 11    // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 12    // See the License for the specific language governing permissions and
 13    // limitations under the License.
 14   
 15    package org.apache.hivemind.util;
 16   
 17    import java.util.Locale;
 18    import java.util.NoSuchElementException;
 19   
 20    import org.apache.hivemind.HiveMind;
 21   
 22    /**
 23    * Used in a wide variety of resource searches. Generates
 24    * a series of name variations from a base name, a
 25    * {@link java.util.Locale} and an optional suffix.
 26    *
 27    * @author Howard Lewis Ship
 28    */
 29   
 30    public class LocalizedNameGenerator
 31    {
 32    private int _baseNameLength;
 33    private String _suffix;
 34    private StringBuffer _buffer;
 35    private String _language;
 36    private String _country;
 37    private String _variant;
 38    private int _state;
 39    private int _prevState;
 40   
 41    private static final int INITIAL = 0;
 42    private static final int LCV = 1;
 43    private static final int LC = 2;
 44    private static final int LV = 3;
 45    private static final int L = 4;
 46    private static final int BARE = 5;
 47    private static final int EXHAUSTED = 6;
 48   
 49  31 public LocalizedNameGenerator(String baseName, Locale locale, String suffix)
 50    {
 51  31 _baseNameLength = baseName.length();
 52   
 53  31 if (locale != null)
 54    {
 55  27 _language = locale.getLanguage();
 56  27 _country = locale.getCountry();
 57  27 _variant = locale.getVariant();
 58    }
 59   
 60  31 _state = INITIAL;
 61  31 _prevState = INITIAL;
 62   
 63  31 _suffix = suffix;
 64   
 65  31 _buffer = new StringBuffer(baseName);
 66   
 67  31 advance();
 68    }
 69   
 70  94 private void advance()
 71    {
 72  94 _prevState = _state;
 73   
 74  179 while (_state != EXHAUSTED)
 75    {
 76  179 _state++;
 77   
 78  179 switch (_state)
 79    {
 80  31 case LCV :
 81   
 82  31 if (HiveMind.isBlank(_variant))
 83  30 continue;
 84   
 85  1 return;
 86   
 87  31 case LC :
 88   
 89  31 if (HiveMind.isBlank(_country))
 90  20 continue;
 91   
 92  11 return;
 93   
 94  31 case LV :
 95   
 96    // If _country is null, then we've already generated this string
 97    // as state LCV and we can continue directly to state L
 98   
 99  31 if (HiveMind.isBlank(_variant) || HiveMind.isBlank(_country))
 100  31 continue;
 101   
 102  0 return;
 103   
 104  31 case L :
 105   
 106  31 if (HiveMind.isBlank(_language))
 107  4 continue;
 108   
 109  27 return;
 110   
 111  31 case BARE :
 112  24 default :
 113  55 return;
 114    }
 115    }
 116    }
 117   
 118    /**
 119    * Returns true if there are more name variants to be
 120    * returned, false otherwise.
 121    *
 122    **/
 123   
 124  81 public boolean more()
 125    {
 126  81 return _state != EXHAUSTED;
 127    }
 128   
 129    /**
 130    * Returns the next localized variant.
 131    *
 132    * @throws NoSuchElementException if all variants have been
 133    * returned.
 134    *
 135    **/
 136   
 137  64 public String next()
 138    {
 139  64 if (_state == EXHAUSTED)
 140  1 throw new NoSuchElementException();
 141   
 142  63 String result = build();
 143   
 144  63 advance();
 145   
 146  63 return result;
 147    }
 148   
 149  63 private String build()
 150    {
 151  63 _buffer.setLength(_baseNameLength);
 152   
 153  63 if (_state == LC || _state == LCV || _state == L)
 154    {
 155  39 _buffer.append('_');
 156  39 _buffer.append(_language);
 157    }
 158   
 159    // For LV, we want two underscores between language
 160    // and variant.
 161   
 162  63 if (_state == LC || _state == LCV || _state == LV)
 163    {
 164  12 _buffer.append('_');
 165   
 166  12 if (_state != LV)
 167  12 _buffer.append(_country);
 168    }
 169   
 170  63 if (_state == LV || _state == LCV)
 171    {
 172  1 _buffer.append('_');
 173  1 _buffer.append(_variant);
 174    }
 175   
 176  63 if (_suffix != null)
 177  62 _buffer.append(_suffix);
 178   
 179  63 return _buffer.toString();
 180    }
 181   
 182  27 public Locale getCurrentLocale()
 183    {
 184  27 switch (_prevState)
 185    {
 186  0 case LCV :
 187   
 188  0 return new Locale(_language, _country, _variant);
 189   
 190  5 case LC :
 191   
 192  5 return new Locale(_language, _country, "");
 193   
 194  0 case LV :
 195   
 196  0 return new Locale(_language, "", _variant);
 197   
 198  11 case L :
 199   
 200  11 return new Locale(_language, "", "");
 201   
 202  11 default :
 203  11 return null;
 204    }
 205    }
 206    }