469 lines
15 KiB
Java
469 lines
15 KiB
Java
/*
|
|
*****************************************************************************
|
|
* Copyright (C) 2000-2004, International Business Machines Corporation and *
|
|
* others. All Rights Reserved. *
|
|
*****************************************************************************
|
|
*/
|
|
package com.ibm.rbm;
|
|
|
|
|
|
import java.io.IOException;
|
|
import java.io.PrintStream;
|
|
import java.io.Writer;
|
|
import java.util.*;
|
|
|
|
import com.ibm.rbm.gui.RBManagerGUI;
|
|
|
|
/**
|
|
* A class representing the entire Bundle of Resources for a particular language, country, variant.
|
|
*
|
|
* @author Jared Jackson
|
|
* @see com.ibm.rbm.RBManager
|
|
*/
|
|
public class Bundle {
|
|
|
|
/**
|
|
* The following public class variables reflect the various properties that can be included as
|
|
* meta-data in a resource bundle formatted by RBManager
|
|
*/
|
|
public String name;
|
|
/**
|
|
* The encoding of the bundle (e.g. 'en', 'en_US', 'de', etc.)
|
|
*/
|
|
public String encoding;
|
|
/**
|
|
* A descriptor of the language in the encoding (e.g. English, German, etc.)
|
|
*/
|
|
public String language;
|
|
/**
|
|
* A descriptor of the country in the encoding (e.g. US, Canada, Great Britain)
|
|
*/
|
|
public String country;
|
|
/**
|
|
* The descriptor of the variant in the encoding (e.g. Euro, Irish, etc.)
|
|
*/
|
|
public String variant;
|
|
/**
|
|
* A comment concerning the bundle
|
|
*/
|
|
public String comment;
|
|
/**
|
|
* The name of the person responsible for the managerment of this bundle
|
|
*/
|
|
public String manager;
|
|
|
|
private TreeSet groups; // A vector of groups of NLS items, the key is the group name
|
|
|
|
/**
|
|
* A hashtable of all of the items in the bundle, hashed according to their
|
|
* NLS key.
|
|
*/
|
|
|
|
public Hashtable allItems; // A hashtable of all items in the file, the key is the NLS key
|
|
|
|
private TreeSet untranslatedItems; // A vector of all items which are untranslated
|
|
|
|
/**
|
|
* A vector containing all of the items which are duplicates (based on the NLS keys)
|
|
* of items previously declared in the bundle.
|
|
*/
|
|
|
|
public Vector duplicates; // A vector of items which are duplicates (NLS Keys) of previous items
|
|
|
|
/**
|
|
* Constructor for creating an empty bundle with a given encoding
|
|
*/
|
|
|
|
public Bundle(String encoding) {
|
|
this.encoding = encoding;
|
|
language = null;
|
|
country = null;
|
|
variant = null;
|
|
comment = null;
|
|
manager = null;
|
|
groups = new TreeSet(new Comparator() {
|
|
public boolean equals(Object o) { return false; }
|
|
|
|
public int compare(Object o1, Object o2) {
|
|
if (!(o1 instanceof BundleGroup) || !(o2 instanceof BundleGroup))
|
|
return 0;
|
|
BundleGroup g1 = (BundleGroup)o1;
|
|
BundleGroup g2 = (BundleGroup)o2;
|
|
return g1.getName().compareTo(g2.getName());
|
|
}
|
|
});
|
|
|
|
untranslatedItems = new TreeSet(new Comparator() {
|
|
public boolean equals(Object o) { return false; }
|
|
|
|
public int compare(Object o1, Object o2) {
|
|
if (!(o1 instanceof BundleItem) || !(o2 instanceof BundleItem)) return 0;
|
|
BundleItem i1 = (BundleItem)o1;
|
|
BundleItem i2 = (BundleItem)o2;
|
|
return i1.getKey().compareTo(i2.getKey());
|
|
}
|
|
});
|
|
|
|
duplicates = new Vector();
|
|
allItems = new Hashtable();
|
|
}
|
|
|
|
/**
|
|
* Encodings are of the form -> language_country_variant <- (for example: "en_us_southern").
|
|
* This method returns the language encoding string, or null if it is not specified
|
|
*/
|
|
|
|
public String getLanguageEncoding() {
|
|
if (encoding == null)
|
|
return null;
|
|
if (encoding.indexOf("_") >= 0)
|
|
return encoding.substring(0,encoding.indexOf("_"));
|
|
return encoding.trim();
|
|
}
|
|
|
|
/**
|
|
* Encodings are of the form -> language_country_variant <- (for example: "en_us_southern").
|
|
* This method returns the country encoding string, or null if it is not specified
|
|
*/
|
|
|
|
public String getCountryEncoding() {
|
|
if (encoding == null || encoding.indexOf("_") < 0)
|
|
return null;
|
|
// Strip off the language
|
|
String workStr = encoding.substring(encoding.indexOf("_")+1,encoding.length());
|
|
if (workStr.indexOf("_") >= 0)
|
|
return workStr.substring(0,encoding.indexOf("_"));
|
|
return workStr.trim();
|
|
}
|
|
|
|
/**
|
|
* Encodings are of the form -> language_country_variant <- (for example: "en_us_southern").
|
|
* This method returns the variant encoding string, or null if it is not specified
|
|
*/
|
|
|
|
public String getVariantEncoding() {
|
|
if (encoding == null || encoding.indexOf("_") < 0)
|
|
return null;
|
|
// Strip off the language
|
|
String workStr = encoding.substring(encoding.indexOf("_")+1,encoding.length());
|
|
if (workStr == null || workStr.length() < 1 || workStr.indexOf("_") < 0)
|
|
return null;
|
|
// Strip off the country
|
|
workStr = workStr.substring(encoding.indexOf("_")+1, workStr.length());
|
|
return workStr.trim();
|
|
}
|
|
|
|
/**
|
|
* Returns the UntranslatedItems as a vector. I should find where this happens and stop it.
|
|
*/
|
|
|
|
public Vector getUntranslatedItemsAsVector() {
|
|
Iterator iter = untranslatedItems.iterator();
|
|
Vector v = new Vector();
|
|
while (iter.hasNext())
|
|
v.addElement(iter.next());
|
|
return v;
|
|
}
|
|
|
|
/**
|
|
* Checks all items in the untranslated items set. If they belong to a group whose name
|
|
* matches the passed in name, then they are removed.
|
|
*/
|
|
|
|
public void removeUntranslatedItemsByGroup(String groupName) {
|
|
Iterator iter = untranslatedItems.iterator();
|
|
try {
|
|
while(iter.hasNext()) {
|
|
BundleItem item = null;
|
|
item = (BundleItem)iter.next();
|
|
if (item != null && item.getParentGroup().getName().equals(groupName)) {
|
|
removeUntranslatedItem(item.getKey());
|
|
}
|
|
}
|
|
} catch (Exception e) {
|
|
RBManagerGUI.debugMsg(e.getMessage());
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Checks to see if an item of the given key name exists in the set of untranslated items. If
|
|
* it does exist, then it is removed.
|
|
*/
|
|
|
|
public void removeUntranslatedItem(String name) {
|
|
Iterator iter = untranslatedItems.iterator();
|
|
while (iter.hasNext()) {
|
|
BundleItem item = (BundleItem)iter.next();
|
|
if (item.getKey().equals(name)) {
|
|
untranslatedItems.remove(item);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Returns the boolean of wether a group of a given name exists in the bundle
|
|
*/
|
|
|
|
public boolean hasGroup(String groupName) {
|
|
Iterator iter = groups.iterator();
|
|
while (iter.hasNext()) {
|
|
BundleGroup group = (BundleGroup)iter.next();
|
|
if (group.getName().equals(groupName))
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Creates a group of the given name and optionally associates a comment with
|
|
* that group.
|
|
*/
|
|
|
|
public void addBundleGroup(String groupName, String groupComment) {
|
|
BundleGroup bg = new BundleGroup(this, groupName);
|
|
bg.setComment(groupComment);
|
|
addBundleGroup(bg);
|
|
}
|
|
|
|
/**
|
|
* Removes the group of the given name if it exists in the bundle
|
|
*/
|
|
|
|
public void removeGroup(String groupName) {
|
|
Iterator iter = groups.iterator();
|
|
while (iter.hasNext()) {
|
|
BundleGroup tempGroup = (BundleGroup)iter.next();
|
|
if (tempGroup.getName().equals(groupName)) {
|
|
groups.remove(tempGroup);
|
|
break;
|
|
}
|
|
}
|
|
// Remove the items from the untanslated items
|
|
removeUntranslatedItemsByGroup(groupName);
|
|
|
|
// Loop through all Items
|
|
Enumeration enum = allItems.elements();
|
|
while(enum.hasMoreElements()) {
|
|
BundleItem item = (BundleItem)enum.nextElement();
|
|
if (item.getParentGroup().getName().equals(groupName)) {
|
|
allItems.remove(item);
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Removes a single resource item from the bundle
|
|
*/
|
|
|
|
public void removeItem(String key) {
|
|
Object o = allItems.get(key);
|
|
if (o != null) {
|
|
BundleItem item = (BundleItem)o;
|
|
// Remove from allItems Hashtable
|
|
allItems.remove(key);
|
|
// Remove from item's group
|
|
if (item.getParentGroup() != null) {
|
|
BundleGroup group = item.getParentGroup();
|
|
group.removeBundleItem(key);
|
|
}
|
|
// Remove from untranslatedItems Hashtable
|
|
removeUntranslatedItem(key);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Attempts to add a BundleItem to the untranslatedItems. The addition will fail in two cases: One, if
|
|
* the item does not all ready belong to this Bundle, and Two, if the item is all ready in the set of
|
|
* untranslated items.
|
|
*/
|
|
|
|
public void addUntranslatedItem(BundleItem item) {
|
|
if (item.getParentGroup().getParentBundle() != this)
|
|
return;
|
|
// Remove it if it exists.
|
|
if (untranslatedItems.contains(item)) {
|
|
untranslatedItems.remove(item);
|
|
}
|
|
untranslatedItems.add(item);
|
|
}
|
|
|
|
/**
|
|
* Returns the number of items currently marked as untranslated
|
|
*/
|
|
|
|
public int getUntranslatedItemsSize() {
|
|
return untranslatedItems.size();
|
|
}
|
|
|
|
/**
|
|
* Returns the indexth untranslated item
|
|
*/
|
|
|
|
public BundleItem getUntranslatedItem(int index) {
|
|
if (index >= untranslatedItems.size())
|
|
return null;
|
|
Iterator iter = untranslatedItems.iterator();
|
|
for (int i=0; i < index; i++)
|
|
iter.next();
|
|
return (BundleItem)iter.next();
|
|
}
|
|
|
|
/**
|
|
* Return the various resource bundle groups stored in a Vector collection.
|
|
*/
|
|
|
|
public Vector getGroupsAsVector() {
|
|
Vector v = new Vector();
|
|
Iterator iter = groups.iterator();
|
|
while (iter.hasNext()) {
|
|
BundleGroup group = (BundleGroup)iter.next();
|
|
v.addElement(group);
|
|
}
|
|
return v;
|
|
}
|
|
|
|
/**
|
|
* Returns the number of groups in the bundle.
|
|
*/
|
|
|
|
public int getGroupCount() {
|
|
return groups.size();
|
|
}
|
|
|
|
/**
|
|
* Returns a bundle group given a certain index.
|
|
*/
|
|
|
|
public BundleGroup getBundleGroup(int index) {
|
|
if (index >= getGroupCount())
|
|
return null;
|
|
Iterator iter = groups.iterator();
|
|
for (int i=0; i < index; i++)
|
|
iter.next();
|
|
return (BundleGroup)iter.next();
|
|
}
|
|
|
|
/**
|
|
* Looks for a bundle group of a given name within a bundle and
|
|
* returns it if found.
|
|
*/
|
|
|
|
public BundleGroup getBundleGroup(String groupName) {
|
|
Iterator iter = groups.iterator();
|
|
while(iter.hasNext()) {
|
|
BundleGroup group = (BundleGroup)iter.next();
|
|
if (group.getName().equals(groupName))
|
|
return group;
|
|
}
|
|
return null;
|
|
}
|
|
|
|
/**
|
|
* Looks up and returns a bundle item stored in the bundle based on its
|
|
* NLS lookup key.
|
|
*/
|
|
|
|
public BundleItem getBundleItem(String key) {
|
|
return (BundleItem)allItems.get(key);
|
|
}
|
|
|
|
/**
|
|
* One group is created for all bundles called 'Ungrouped Items'. This is the bundle
|
|
* group in which bundle items are placed that are not specifically grouped in the
|
|
* resource bundle file. This method returns that bundle group.
|
|
*/
|
|
|
|
public BundleGroup getUngroupedGroup() {
|
|
return getBundleGroup("Ungrouped Items");
|
|
}
|
|
|
|
/**
|
|
* Add a bundle group to the bundle
|
|
*/
|
|
|
|
public void addBundleGroup(BundleGroup bg) {
|
|
groups.add(bg);
|
|
}
|
|
|
|
/**
|
|
* Add a bundle item to the bundle. This bundle item should all ready have its
|
|
* bundle group assigned.
|
|
*/
|
|
|
|
public void addBundleItem(BundleItem item) {
|
|
if (allItems.containsKey(item.getKey())) {
|
|
duplicates.addElement(item);
|
|
} else {
|
|
if (!(groups.contains(item.getParentGroup())))
|
|
addBundleGroup(item.getParentGroup());
|
|
item.getParentGroup().addBundleItem(item);
|
|
allItems.put(item.getKey(), item);
|
|
if (!item.isTranslated())
|
|
addUntranslatedItem(item);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* A method useful in debugging. The string returned displays the encoding
|
|
* information about the bundle and wether or not it is the base class of
|
|
* a resource bundle.
|
|
*/
|
|
|
|
public String toString() {
|
|
String retStr = new String();
|
|
if (language != null && !language.equals("")) retStr = language;
|
|
if (country != null && !country.equals("")) retStr += ", " + country;
|
|
if (variant != null && !variant.equals("")) retStr += ", " + variant;
|
|
|
|
retStr += " (" + (encoding == null || encoding.equals("") ? "Base Class" : encoding) + ")";
|
|
return retStr;
|
|
}
|
|
|
|
/**
|
|
* This method produces a String which is suitable for inclusion in a .properties
|
|
* style resource bundle. It attaches (in comments) the meta data that RBManager
|
|
* reads to manage the resource bundle file. This portion of the output should
|
|
* be included at the beginning of the resource bundle file.
|
|
*/
|
|
|
|
public String toOutputString() {
|
|
String retStr = "# @file " + name + "\n";
|
|
if (encoding != null) retStr += "# @fileEncoding " + encoding + "\n";
|
|
if (language != null) retStr += "# @fileLanguage " + language + "\n";
|
|
if (country != null) retStr += "# @fileCountry " + country + "\n";
|
|
if (variant != null) retStr += "# @fileVariant " + variant + "\n";
|
|
if (manager != null) retStr += "# @fileManager " + manager + "\n";
|
|
if (comment != null) retStr += "# @fileComment " + comment + "\n";
|
|
return retStr;
|
|
}
|
|
|
|
/**
|
|
* A helping method for outputting the formatted contents of the bundle to a
|
|
* print stream. The method first outputs the header information and then outputs
|
|
* each bundle group's formatted data which includes each bundle item.
|
|
*/
|
|
|
|
public void writeContents(PrintStream ps) {
|
|
ps.println(this.toOutputString());
|
|
Iterator iter = groups.iterator();
|
|
while (iter.hasNext()) {
|
|
((BundleGroup)iter.next()).writeContents(ps);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* A helping method for outputting the formatted contents of the bundle to a
|
|
* ouput Writer (such as a FileWriter). The method first outputs the header
|
|
* information and then outputs each bundle group's formatted data which includes
|
|
* each bundle item.
|
|
*/
|
|
|
|
public void writeContents(Writer w) throws IOException {
|
|
w.write(this.toOutputString() + "\n");
|
|
Iterator iter = groups.iterator();
|
|
while (iter.hasNext()) {
|
|
((BundleGroup)iter.next()).writeContents(w);
|
|
}
|
|
}
|
|
} |