Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * Copyright (c) 2006 Henri Sivonen
   * Copyright (c) 2007-2010 Mozilla Foundation
   *
   * Permission is hereby granted, free of charge, to any person obtaining a 
   * copy of this software and associated documentation files (the "Software"), 
   * to deal in the Software without restriction, including without limitation 
   * the rights to use, copy, modify, merge, publish, distribute, sublicense, 
   * and/or sell copies of the Software, and to permit persons to whom the 
  * Software is furnished to do so, subject to the following conditions:
  *
  * The above copyright notice and this permission notice shall be included in 
  * all copies or substantial portions of the Software.
  *
  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 
  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 
  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 
  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING 
  * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER 
  * DEALINGS IN THE SOFTWARE.
  */
 
 package nu.validator.datatype.data;
 
 import java.util.Map;
 import java.util.Set;
 
 public class LanguageData {
 
     private static final Pattern HYPHEN = Pattern.compile("-");
 
     private static final String[][] EMPTY_DOUBLE_STRING_ARRAY = {};
 
     private static final String[] EMPTY_STRING_ARRAY = {};
 
     private static final String PREFIX = "prefix: ";
 
     private static final String SUPPRESS_SCRIPT = "suppress-script: ";
 
     private static final String SUBTAG = "subtag: ";
 
     private static final String TAG = "tag: ";
 
     private static final String TYPE = "type: ";
 
     private static final String DEPRECATED = "deprecated: ";
 
     private static final String PREFERRED_VALUE = "preferred-value: ";
 
     private BufferedReader in;
 
     private SortedSet<StringlanguageSet = new TreeSet<String>();
 
     private SortedSet<StringextlangSet = new TreeSet<String>();
 
     private SortedSet<StringscriptSet = new TreeSet<String>();
 
     private SortedSet<StringregionSet = new TreeSet<String>();
 
     private SortedSet<StringvariantSet = new TreeSet<String>();
 
     private SortedSet<StringgrandfatheredSet = new TreeSet<String>();
 
     private SortedSet<StringredundantSet = new TreeSet<String>();
 
     private SortedSet<StringdeprecatedLangSet = new TreeSet<String>();
 
     private SortedSet<StringdeprecatedSet = new TreeSet<String>();
 
     private Map<StringStringsuppressedScriptByLanguageMap = new HashMap<StringString>();
 
     private Map<StringStringprefixByExtlangMap = new HashMap<StringString>();
 
     private Map<StringStringpreferredValueByLanguageMap = new HashMap<StringString>();
 
     private Map<StringSet<String[]>> prefixesByVariantMap = new HashMap<StringSet<String[]>>();
 
     private String[] languages = null;
 
     private String[] extlangs = null;
 
     private String[] scripts = null;
 
     private String[] regions = null;
 
     private String[] variants = null;
 
     private String[] grandfathered = null;
 
    private String[] redundant = null;
    private String[] deprecatedLang = null;
    private String[] deprecated = null;
    private int[] suppressedScriptByLanguage = null;
    private int[] prefixByExtlang = null;
    private String[][][] prefixesByVariant = null;
    public LanguageData() throws IOException {
        super();
         = new BufferedReader(
                new InputStreamReader(
                        LanguageData.class.getClassLoader().getResourceAsStream(
                                "nu/validator/localentities/files/subtag-registry"),
                        "UTF-8"));
        consumeRegistry();
        prepareArrays();
    }
    private void consumeRegistry() throws IOException {
        while (consumeRecord()) {
            // spin
        }
        .close();
    }
    private void prepareArrays() throws IOException {
        int i = 0;
         = new String[.size()];
         = new int[.size()];
        for (String language : ) {
            [i] = language;
            String suppressed = .get(language);
            if (suppressed == null) {
                [i] = -1;
            } else {
                int index = Arrays.binarySearch(suppressed);
                if (index < 0) {
                    throw new IOException(
                            "Malformed registry: reference to non-existent script.");
                }
                [i] = index;
            }
            i++;
        }
        i = 0;
         = new String[.size()];
         = new int[.size()];
        for (String extlang : ) {
            [i] = extlang;
            String prefix = .get(extlang);
            if (prefix == null) {
                [i] = -1;
            } else {
                int index = Arrays.binarySearch(prefix);
                if (index < 0) {
                    throw new IOException(
                            "Malformed registry: reference to non-existent prefix for extlang.");
                }
                [i] = index;
            }
            i++;
        }
        i = 0;
         = new String[.size()];
         = new String[.size()][][];
        for (String variant : ) {
            [i] = variant;
            Set<String[]> prefixes = .get(variant);
            if (prefixes != null) {
                [i] = prefixes.toArray();
            } else {
                [i] = ;
            }
            i++;
        }
    }
    private boolean consumeRecord() throws IOException {
        boolean hasMore = true;
        String type = null;
        String subtag = null;
        String suppressScript = null;
        String preferredValue = null;
        Set<String[]> prefixes = new HashSet<String[]>();
        String singlePrefix = null;
        boolean depr = false;
        String line = null;
        for (;;) {
            line = .readLine();
            if (line == null) {
                hasMore = false;
                break;
            }
            line = line.toLowerCase();
            if ("%%".equals(line)) {
                break;
            } else if (line.startsWith()) {
                type = line.substring(.length()).trim().intern();
            } else if (line.startsWith()) {
                subtag = line.substring(.length()).trim().intern();
            } else if (line.startsWith()) {
                subtag = line.substring(.length()).trim().intern();
            } else if (line.startsWith()) {
                suppressScript = line.substring(.length()).trim().intern();
            } else if (line.startsWith()) {
                String[] prefixSubtags = .split(line.substring(
                        .length()).trim());
                for (int i = 0; i < prefixSubtags.lengthi++) {
                    prefixSubtags[i] = prefixSubtags[i].intern();
                }
                prefixes.add(prefixSubtags);
                singlePrefix = prefixSubtags[0];
            } else if (line.startsWith()) {
                depr = true;
            } else if (line.startsWith()) {
                preferredValue = line.substring(.length()).trim().intern();
                .put(subtagpreferredValue);
            }
        }
        if (subtag == null) {
            return hasMore;
        }
        if (depr) {
            if ("language" == type) {
                .add(subtag);
            } else {
                .add(subtag);
            }
        }
        if ("language" == type) {
            .add(subtag);
            .put(subtagsuppressScript);
        }
        if ("extlang" == type) {
            .add(subtag);
            .put(subtagsinglePrefix);
        } else if ("region" == type) {
            .add(subtag);
        } else if ("script" == type) {
            .add(subtag);
        } else if ("variant" == type) {
            .add(subtag);
            .put(subtagprefixes);
        } else if ("grandfathered" == type) {
            .add(subtag);
        } else if ("redundant" == type) {
            .add(subtag);
        }
        return hasMore;
    }

    
Returns the languages.

Returns:
the languages
    public String[] getLanguages() {
        return ;
    }
    public String[] getExtlangs() {
        return ;
    }

    
Returns the prefixesByVariant.

Returns:
the prefixesByVariant
    public String[][][] getPrefixesByVariant() {
        return ;
    }
    public int[] getPrefixByExtlang() {
        return ;
    }

    
Returns the regions.

Returns:
the regions
    public String[] getRegions() {
        return ;
    }

    
Returns the scripts.

Returns:
the scripts
    public String[] getScripts() {
        return ;
    }

    
Returns the suppressedScriptByLanguage.

Returns:
the suppressedScriptByLanguage
    public int[] getSuppressedScriptByLanguage() {
        return ;
    }

    
Returns the variants.

Returns:
the variants
    public String[] getVariants() {
        return ;
    }

    
Returns the deprecated.

Returns:
the deprecated
    public String[] getDeprecated() {
        return ;
    }

    
Returns the preferredValueByLanguageMap.

Returns:
the preferredValueByLanguageMap
        return ;
    }

    
Returns the grandfathered.

Returns:
the grandfathered
    public String[] getGrandfathered() {
        return ;
    }

    
Returns the redundant.

Returns:
the redundant
    public String[] getRedundant() {
        return ;
    }

    
Returns the deprecatedLang.

Returns:
the deprecatedLang
    public String[] getDeprecatedLang() {
        return ;
    }
New to GrepCode? Check out our FAQ X