home *** CD-ROM | disk | FTP | other *** search
/ AmigActive 6 / AACD06.ISO / AACD / Programming / ICU / src / icu / source / common / resbund.h < prev    next >
Encoding:
C/C++ Source or Header  |  1999-10-19  |  31.4 KB  |  630 lines
  1. /*
  2. *******************************************************************************
  3. *                                                                             *
  4. * COPYRIGHT:                                                                  *
  5. *   (C) Copyright Taligent, Inc., 1996 1997                                   *
  6. *   (C) Copyright International Business Machines Corporation, 1996 - 1999    *
  7. *   Licensed Material - Program-Property of IBM - All Rights Reserved.        *
  8. *   US Government Users Restricted Rights - Use, duplication, or disclosure   *
  9. *   restricted by GSA ADP Schedule Contract with IBM Corp.                    *
  10. *                                                                             *
  11. *******************************************************************************
  12. *
  13. * File resbund.h
  14. *
  15. *   CREATED BY
  16. *       Richard Gillam
  17. *
  18. * Modification History:
  19. *
  20. *   Date        Name        Description
  21. *   2/5/97      aliu        Added scanForLocaleInFile.  Added
  22. *                           constructor which attempts to read resource bundle
  23. *                           from a specific file, without searching other files.
  24. *   2/11/97     aliu        Added UErrorCode return values to constructors.  Fixed
  25. *                           infinite loops in scanForFile and scanForLocale.
  26. *                           Modified getRawResourceData to not delete storage in
  27. *                           localeData and resourceData which it doesn't own.
  28. *                           Added Mac compatibility #ifdefs for tellp() and
  29. *                           ios::nocreate.
  30. *   2/18/97     helena      Updated with 100% documentation coverage.
  31. *   3/13/97     aliu        Rewrote to load in entire resource bundle and store
  32. *                           it as a Hashtable of ResourceBundleData objects.
  33. *                           Added state table to govern parsing of files.
  34. *                           Modified to load locale index out of new file distinct
  35. *                           from default.txt.
  36. *   3/25/97     aliu        Modified to support 2-d arrays, needed for timezone data.
  37. *                           Added support for custom file suffixes.  Again, needed to
  38. *                           support timezone data.
  39. *   4/7/97      aliu        Cleaned up.
  40. * 03/02/99      stephen     Removed dependency on FILE*.
  41. * 03/29/99      helena      Merged Bertrand and Stephen's changes.
  42. * 06/11/99      stephen     Removed parsing of .txt files.
  43. *                           Reworked to use new binary format.
  44. *                           Cleaned up.
  45. * 06/14/99      stephen     Removed methods taking a filename suffix.
  46. *******************************************************************************
  47. */
  48.  
  49. #ifndef RESBUND_H
  50. #define RESBUND_H
  51.   
  52. #include "utypes.h"
  53. #include "unistr.h"
  54. #include "locid.h"
  55. #include <wchar.h>
  56.  
  57.  
  58. class RBHashtable;
  59. class ResourceBundleData;
  60. class ResourceBundleCache;
  61. class VisitedFileCache;
  62. #ifndef _FILESTRM
  63. typedef struct _FileStream FileStream;
  64. #endif
  65.  
  66. /**
  67.  * A class representing a collection of resource information pertaining to a given
  68.  * locale. A resource bundle provides a way of accessing locale- specfic information in
  69.  * a data file. You create a resource bundle that manages the resources for a given
  70.  * locale and then ask it for individual resources.
  71.  * <P>
  72.  * The resource bundle file is a text (ASCII or Unicode) file with the format:
  73.  * <pre>
  74.  * .   locale {
  75.  * .      tag1 {...}
  76.  * .      tag2 {...}
  77.  * .   }
  78.  * </pre>
  79.  * The tags are used to retrieve the data later. You may not have multiple instances of
  80.  * the same tag.
  81.  * <P>
  82.  * Four data types are supported. These are solitary strings, comma-delimited lists of
  83.  * strings, 2-dimensional arrays of strings, and tagged lists of strings.
  84.  * <P>
  85.  * Note that all data is textual. Adjacent strings are merged by the low-level
  86.  * tokenizer, so that the following effects occur: foo bar, baz // 2 elements, "foo
  87.  * bar", and "baz" "foo" "bar", baz // 2 elements, "foobar", and "baz" Note that a
  88.  * single intervening space is added between merged strings, unless they are both double
  89.  * quoted. This extends to more than two strings in a row.
  90.  * <P>
  91.  * Whitespace is ignored, as in a C source file.
  92.  * <P>
  93.  * Solitary strings have the format:
  94.  * <pre>
  95.  * .   Tag { Data }
  96.  * </pre>
  97.  * This is indistinguishable from a comma-delimited list with only one element, and in
  98.  * fact may be retrieved as such (as an array, or as element 0 or an array).
  99.  * <P>
  100.  * Comma-delimited lists have the format:
  101.  * <pre>
  102.  * .   Tag { Data, Data, Data }
  103.  * </pre>
  104.  * Parsing is lenient; a final string, after the last element, is allowed.
  105.  * <P>
  106.  * Tagged lists have the format:
  107.  * <pre>
  108.  * .   Tag { Subtag { Data } Subtag {Data} }
  109.  * </pre>
  110.  * Data is retrieved by specifying the subtag.
  111.  * <P>
  112.  * Two-dimensional arrays have the format:
  113.  * <pre>
  114.  * .   TwoD {
  115.  * .       { r1c1, r1c2, ..., r1cm },
  116.  * .       { r2c1, r2c2, ..., r2cm },
  117.  * .       ...
  118.  * .       { rnc1, rnc2, ..., rncm }
  119.  * .   }
  120.  * </pre>
  121.  * where n is the number of rows, and m is the number of columns. Parsing is lenient (as
  122.  * in other data types). A final comma is always allowed after the last element; either
  123.  * the last string in a row, or the last row itself. Furthermore, since there is no
  124.  * ambiguity, the commas between the rows are entirely optional. (However, if a comma is
  125.  * present, there can only be one comma, no more.) It is possible to have zero columns,
  126.  * as follows:
  127.  * <pre>
  128.  * .   Odd { {} {} {} } // 3 x 0 array
  129.  * </pre>
  130.  * But it is impossible to have zero rows. The smallest array is thus a 1 x 0 array,
  131.  * which looks like this:
  132.  * <pre>
  133.  * .   Smallest { {} } // 1 x 0 array
  134.  * </pre>
  135.  * The array must be strictly rectangular; that is, each row must have the same number
  136.  * of elements.
  137.  * <P>
  138.  * This is an example for using a possible custom resource:
  139.  * <pre>
  140.  * .    Locale currentLocale;
  141.  * .    UErrorCode success = U_ZERO_ERROR;
  142.  * .    ResourceBundle myResources("MyResources", currentLocale, success );
  143.  * .
  144.  * .    UnicodeString button1Title, button2Title;
  145.  * .    myResources.getString("OkKey", button1Title, success );
  146.  * .    myResources.getString("CancelKey", button2Title, success );
  147.  * </pre>
  148.  */
  149. class U_COMMON_API ResourceBundle {
  150. public:
  151.     /**
  152.      * Constructor
  153.      *
  154.      * @param path    This is a full pathname in the platform-specific format for the
  155.      *                directory containing the resource data files we want to load
  156.      *                resources from. We use locale IDs to generate filenames, and the
  157.      *                filenames have this string prepended to them before being passed
  158.      *                to the C++ I/O functions. Therefore, this string must always end
  159.      *                with a directory delimiter (whatever that is for the target OS)
  160.      *                for this class to work correctly.
  161.      * @param locale  This is the locale this resource bundle is for. To get resources
  162.      *                for the French locale, for example, you would create a
  163.      *                ResourceBundle passing Locale::FRENCH for the "locale" parameter,
  164.      *                and all subsequent calls to that resource bundle will return
  165.      *                resources that pertain to the French locale. If the caller doesn't
  166.      *                pass a locale parameter, the default locale for the system (as
  167.      *                returned by Locale::getDefault()) will be used.
  168.      * The UErrorCode& err parameter is used to return status information to the user. To
  169.      * check whether the construction succeeded or not, you should check the value of
  170.      * U_SUCCESS(err). If you wish more detailed information, you can check for
  171.      * informational error results which still indicate success. U_USING_FALLBACK_ERROR
  172.      * indicates that a fall back locale was used. For example, 'de_CH' was requested,
  173.      * but nothing was found there, so 'de' was used. U_USING_DEFAULT_ERROR indicates that
  174.      * the default locale data was used; neither the requested locale nor any of its
  175.      * fall back locales could be found.
  176.      */
  177.                         ResourceBundle( const UnicodeString&    path,
  178.                                         const Locale&           locale,
  179.                                         UErrorCode&              err);
  180.                         ResourceBundle( const UnicodeString&    path,
  181.                                         UErrorCode&              err);
  182.                         ResourceBundle( const wchar_t* path,
  183.                                         const Locale& locale,
  184.                                         UErrorCode& err);
  185.                         ~ResourceBundle();
  186.  
  187.     /**
  188.      * Returns the contents of a string resource. Resource data is undifferentiated
  189.      * Unicode text. The resource file may contain quoted strings or escape sequences;
  190.      * these will be parsed prior to the data's return.
  191.      * [THIS FUNCTION IS DERECATED; USE THE OVERLOAD BELOW INSTEAD]
  192.      *
  193.      * @param resourceTag  The resource tag of the string resource the caller wants
  194.      * @param theString    Receives the actual data in the resource
  195.      * @param err          Set to U_MISSING_RESOURCE_ERROR if a resource with the
  196.      *                     specified tag couldn't be found.
  197.      */
  198.     void                getString(  const UnicodeString&    resourceTag,
  199.                                     UnicodeString&          theString,
  200.                                     UErrorCode&              err) const;
  201.  
  202.     /**
  203.      * Returns the contents of a string resource. Resource data is undifferentiated
  204.      * Unicode text. The resource file may contain quoted strings or escape sequences;
  205.      * these will be parsed prior to the data's return.
  206.      *
  207.      * @param resourceTag  The resource tag of the string resource the caller wants
  208.      * @param err          Set to U_MISSING_RESOURCE_ERROR if a resource with the
  209.      *                     specified tag couldn't be found.
  210.      * @return A pointer to the string from the resource bundle, or NULL if there was
  211.      *           an error.
  212.      */
  213.     const UnicodeString*    getString(    const UnicodeString&    resourceTag,
  214.                                         UErrorCode&                err) const;
  215.  
  216.     /**
  217.      * Returns the contents of a string-array resource. This will return the contents of
  218.      * a string-array (comma-delimited-list) resource as a C++ array of UnicodeString
  219.      * objects. The number of elements in the array is returned in numArrayItems.
  220.      * Calling getStringArray on a resource of type string will return an array with one
  221.      * element; calling it on a resource of type tagged-array results in a
  222.      * U_MISSING_RESOURCE_ERROR error.
  223.      *
  224.      * @param resourceTag    The resource tag of the string-array resource the caller
  225.      *                       wants
  226.      * @param numArrayItems  Receives the number of items in the array the function
  227.      *                       returns.
  228.      * @param err            Set to U_MISSING_RESOURCE_ERROR if a resource with the
  229.      *                       specified tag couldn't be found.
  230.      * @return               The resource requested, as a pointer to an array of
  231.      *                       UnicodeStrings. The caller does not own the storage and
  232.      *                       must not delete it.
  233.      */
  234.     const UnicodeString*    getStringArray( const UnicodeString&    resourceTag,
  235.                                             int32_t&                numArrayItems,
  236.                                             UErrorCode&              err) const;
  237.  
  238.     /**
  239.      * Returns a single item from a string-array resource. This will return the contents
  240.      * of a single item in a resource of string-array (comma-delimited-list) type. If
  241.      * the resource is not an array, a U_MISSING_RESOURCE_ERROR will be returned in err.
  242.      * [THIS FUNCTION IS DEPRECATED; USE THE OVERLOAD BELOW INSTEAD]
  243.      *
  244.      * @param resourceTag   The resource tag of the resource the caller wants to extract
  245.      *                      an item from.
  246.      * @param index         The index (zero-based) of the particular array item the user
  247.      *                      wants to extract from the resource.
  248.      * @param theArrayItem  Receives the actual text of the desired array item.
  249.      * @param err           Set to U_MISSING_RESOURCE_ERROR if a resource with the
  250.      *                      specified tag couldn't be found, or if the index was out of range.
  251.      */
  252.     void                getArrayItem(   const UnicodeString&    resourceTag,
  253.                                         int32_t                 index,
  254.                                         UnicodeString&          theArrayItem,
  255.                                         UErrorCode&              err) const;
  256.  
  257.     /**
  258.      * Returns a single item from a string-array resource. This will return the contents
  259.      * of a single item in a resource of string-array (comma-delimited-list) type. If
  260.      * the resource is not an array, a U_MISSING_RESOURCE_ERROR will be returned in err.
  261.      *
  262.      * @param resourceTag   The resource tag of the resource the caller wants to extract
  263.      *                      an item from.
  264.      * @param index         The index (zero-based) of the particular array item the user
  265.      *                      wants to extract from the resource.
  266.      * @param err           Set to U_MISSING_RESOURCE_ERROR if a resource with the
  267.      *                      specified tag couldn't be found, or if the index was out of range.
  268.      * @return A pointer to the text of the array item, or NULL is there was an error.
  269.      */
  270.     const UnicodeString*    getArrayItem(    const UnicodeString&    resourceTag,
  271.                                             int32_t                    index,
  272.                                             UErrorCode&                err) const;
  273.  
  274.     /**
  275.      * Return the contents of a 2-dimensional array resource. The return value will be a
  276.      * UnicodeString** array. (This is really an array of pointers; each pointer is a
  277.      * ROW of the data.) The number of rows and columns is returned. If the resource is
  278.      * of the wrong type, or not present, U_MISSING_RESOURCE_ERROR is placed in err.
  279.      *
  280.      * @param resourceTag  The resource tag of the string-array resource the caller
  281.      *                     wants
  282.      * @param rowCount     Receives the number of rows in the array the function
  283.      *                     returns.
  284.      * @param columnCount  Receives the number of columns in the array the function
  285.      *                     returns.
  286.      * @param err          Set to U_MISSING_RESOURCE_ERROR if a resource with the
  287.      *                     specified tag couldn't be found.
  288.      * @return             The resource requested, as a UnicodeStrings**. The caller
  289.      *                     does not own the storage and must not delete it.
  290.      */
  291.     const UnicodeString**   get2dArray(const UnicodeString& resourceTag,
  292.                                        int32_t&             rowCount,
  293.                                        int32_t&             columnCount,
  294.                                        UErrorCode&           err) const;
  295.  
  296.     /**
  297.      * Return a single string from a 2-dimensional array resource. If the resource does
  298.      * not exists, or if it is not a 2-d array, or if the row or column indices are out
  299.      * of bounds, err is set to U_MISSING_RESOURCE_ERROR.
  300.      * [THIS FUNCTION IS DEPRECATED; USE THE OVERLOAD BELOW INSTEAD]
  301.      *
  302.      * @param resourceTag   The resource tag of the resource the caller wants to extract
  303.      *                      an item from.
  304.      * @param rowIndex      The row index (zero-based) of the array item the user wants
  305.      *                      to extract from the resource.
  306.      * @param columnIndex   The column index (zero-based) of the array item the user
  307.      *                      wants to extract from the resource.
  308.      * @param theArrayItem  Receives the actual text of the desired array item.
  309.      * @param err           Set to U_MISSING_RESOURCE_ERROR if a resource with the
  310.      *                      specified tag couldn't be found, if the resource data was in
  311.      *                      the wrong format, or if either index is out of bounds.
  312.      */
  313.     void                get2dArrayItem(const UnicodeString& resourceTag,
  314.                                        int32_t              rowIndex,
  315.                                        int32_t              columnIndex,
  316.                                        UnicodeString&       theArrayItem,
  317.                                        UErrorCode&           err) const;
  318.  
  319.     /**
  320.      * Return a single string from a 2-dimensional array resource. If the resource does
  321.      * not exists, or if it is not a 2-d array, or if the row or column indices are out
  322.      * of bounds, err is set to U_MISSING_RESOURCE_ERROR.
  323.      *
  324.      * @param resourceTag   The resource tag of the resource the caller wants to extract
  325.      *                      an item from.
  326.      * @param rowIndex      The row index (zero-based) of the array item the user wants
  327.      *                      to extract from the resource.
  328.      * @param columnIndex   The column index (zero-based) of the array item the user
  329.      *                      wants to extract from the resource.
  330.      * @param err           Set to U_MISSING_RESOURCE_ERROR if a resource with the
  331.      *                      specified tag couldn't be found, if the resource data was in
  332.      *                      the wrong format, or if either index is out of bounds.
  333.      * @return A pointer to the text of the array item, or NULL is there was an error.
  334.      */
  335.     const UnicodeString*    get2dArrayItem(    const UnicodeString&    resourceTag,
  336.                                             int32_t                    rowIndex,
  337.                                             int32_t                    columnIndex,
  338.                                             UErrorCode&                err) const;
  339.  
  340.     /**
  341.      * Returns a single item from a tagged-array resource This will return the contents
  342.      * of a single item in a resource of type tagged-array. If this function is called
  343.      * for a resource that is not of type tagged-array, it will set err to
  344.      * MISSING_RESOUCE_ERROR.
  345.      * [THIS FUNCTION IS DEPRECATED; USE THE OVERLOAD BELOW INSTEAD]
  346.      *
  347.      * @param resourceTag   The resource tag of the resource the caller wants to extract
  348.      *                      an item from.
  349.      * @param itemTag       The item tag for the item the caller wants to extract.
  350.      * @param theArrayItem  Receives the text of the desired array item.
  351.      * @param err           Set to U_MISSING_RESOURCE_ERROR if a resource with the
  352.      *                      specified resource tag couldn't be found, or if an item
  353.      *                      with the specified item tag couldn't be found in the resource.
  354.      */
  355.     void                getTaggedArrayItem( const UnicodeString&    resourceTag,
  356.                                             const UnicodeString&    itemTag,
  357.                                             UnicodeString&          theArrayItem,
  358.                                             UErrorCode&              err) const;
  359.  
  360.     /**
  361.      * Returns a single item from a tagged-array resource This will return the contents
  362.      * of a single item in a resource of type tagged-array. If this function is called
  363.      * for a resource that is not of type tagged-array, it will set err to
  364.      * MISSING_RESOUCE_ERROR.
  365.      *
  366.      * @param resourceTag   The resource tag of the resource the caller wants to extract
  367.      *                      an item from.
  368.      * @param itemTag       The item tag for the item the caller wants to extract.
  369.      * @param err           Set to U_MISSING_RESOURCE_ERROR if a resource with the
  370.      *                      specified resource tag couldn't be found, or if an item
  371.      *                      with the specified item tag coldn't be found in the resource.
  372.      * @return A pointer to the text of the array item, or NULL is there was an error.
  373.      */
  374.     const UnicodeString*    getTaggedArrayItem(    const UnicodeString&    resourceTag,
  375.                                                 const UnicodeString&    itemTag,
  376.                                                 UErrorCode&                err) const;
  377.  
  378.     /**
  379.      * Returns a tagged-array resource.  The contents of the resource is returned as two
  380.      * separate arrays of UnicodeStrings, the addresses of which are placed in "itemTags"
  381.      * and "items".  After calling this function, the items in the resource will be in the
  382.      * list pointed to by "items", and for each items[i], itemTags[i] will be the tag that
  383.      * corresponds to it.  The total number of entries in both arrays is returned in
  384.      * numItems.
  385.      *
  386.      * @param resourceTag   The resource tag of the resource the caller wants to extract
  387.      *                      an item from.
  388.      * @param itemTags      Set to point to an array of UnicodeStrings representing the
  389.      *                      tags in the specified resource.  The caller DOES own this array,
  390.      *                      and must delete it.
  391.      * @param items         Set to point to an array of UnicodeStrings containing the
  392.      *                      individual resource items themselves.  itemTags[i] will
  393.      *                      contain the tag corresponding to items[i].  The caller DOES
  394.      *                      own this array, and must delete it.
  395.      * @param numItems      Receives the number of items in the arrays pointed to by
  396.      *                      items and itemTags.
  397.      * @param err           Set to U_MISSING_RESOURCE_ERROR if a resource with the
  398.      *                      specified tag couldn't be found.
  399.      */
  400.     void                getTaggedArray( const UnicodeString&    resourceTag,
  401.                                         UnicodeString*&         itemTags,
  402.                                         UnicodeString*&         items,
  403.                                         int32_t&                numItems,
  404.                                         UErrorCode&              err) const;
  405.     
  406.     /**
  407.      * Return the version number associated with this ResourceBundle. This version
  408.      * number is a string of the form MAJOR.MINOR, where MAJOR is the version number of
  409.      * the current analytic code package, and MINOR is the version number contained in
  410.      * the resource file as the value of the tag "Version". A change in the MINOR
  411.      * version indicated an updated data file. A change in the MAJOR version indicates a
  412.      * new version of the code which is not binary-compatible with the previous version.
  413.      * If no "Version" tag is present in a resource file, the MINOR version "0" is assigned.
  414.      *
  415.      * For example, if the Collation sort key algorithm changes, the MAJOR version
  416.      * increments. If the collation data in a resource file changes, the MINOR version
  417.      * for that file increments.
  418.      *
  419.      * @return  A string of the form N.n, where N is the major version number,
  420.      *          representing the code version, and n is the minor version number,
  421.      *          representing the resource data file. The caller does not own this
  422.      *          string.
  423.      */
  424.     const char*         getVersionNumber(void) const;
  425.  
  426. private:
  427.     class U_COMMON_API PathInfo {
  428.     public:
  429.         PathInfo();
  430.         PathInfo(const PathInfo& source);
  431.         PathInfo(const UnicodeString& path);
  432.         PathInfo(const UnicodeString& path, const UnicodeString& suffix);
  433.         PathInfo(const wchar_t* path, const wchar_t* suffix);
  434.         ~PathInfo();
  435.  
  436.         PathInfo& operator=(const PathInfo& source);
  437.  
  438.         bool_t fileExists(const UnicodeString& localeName) const;
  439.         UnicodeString makeCacheKey(const UnicodeString& localeName) const;
  440.         UnicodeString makeHashkey(const UnicodeString& localeName) const;
  441.         FileStream* openFile(const UnicodeString& localeName) const;
  442.  
  443.     private:
  444.         static const UChar        kSeparator;
  445.         UnicodeString                fPrefix;
  446.         UnicodeString                fSuffix;
  447.         wchar_t*                    fWPrefix;
  448.         wchar_t*                    fWSuffix;
  449.     };
  450.  
  451. private:
  452.     friend class Locale;
  453.     friend class RuleBasedCollator;
  454.     friend int32_t T_ResourceBundle_countArrayItemsImplementation(const ResourceBundle* resourceBundle, 
  455.                                   const char* resourceKey,
  456.                                   UErrorCode& err) ;
  457.     friend const UnicodeString** listInstalledLocalesImplementation(const char* path,
  458.                                    int32_t* numInstalledLocales);
  459.     friend void getTaggedArrayUCharsImplementation(
  460.                              const ResourceBundle*   bundle,
  461.                              const UnicodeString&    resourceTag,
  462.                              UChar const**         itemTags,
  463.                              UChar const**         items,
  464.                              int32_t                    maxItems,
  465.                              int32_t&                numItems,
  466.                              UErrorCode&              err);
  467.  
  468.  
  469.     /**
  470.      * This constructor is used by Collation to load a resource bundle from a specific
  471.      * file, without trying other files. This is used by the Collation caching
  472.      * mechanism.
  473.      */
  474.                             ResourceBundle( const UnicodeString&    path,
  475.                                             const UnicodeString&    localeName,
  476.                                             UErrorCode&              status);
  477.  
  478.     /**
  479.      * Return a list of all installed locales. This function returns a list of the IDs
  480.      * of all locales represented in the directory specified by this ResourceBundle. It
  481.      * depends on that directory having an "Index" tagged-list item in its "index.txt"
  482.      * file; it parses that list to determine its return value (therefore, that list
  483.      * also has to be up to date). This function is static.
  484.      *
  485.      * This function is the implementation of the Locale::listInstalledLocales()
  486.      * function. It's private because the API for it real;ly belongs in Locale.
  487.      *
  488.      * @param path                 The path to the locale data files. The function will
  489.      *                             look here for "index.txt".
  490.      * @param numInstalledLocales  Receives the number of installed locales, according
  491.      *                             to the Index resource in index.txt.
  492.      * @return                     A list of the installed locales, as a pointer to an
  493.      *                             array of UnicodeStrings. This storage is not owned by
  494.      *                             the caller, who must not delete it. The information
  495.      *                             in this list is derived from the Index resource in
  496.      *                             default.txt, which must be kept up to date.
  497.      */
  498.     static const UnicodeString* listInstalledLocales(const UnicodeString& path,
  499.                                                      int32_t&   numInstalledLocales);
  500.  
  501.     /**
  502.      * Retrieve a ResourceBundle from the cache. Return NULL if not found.
  503.      */
  504.     static const UHashtable* getFromCache(const PathInfo& path,
  505.                                          const UnicodeString& localeName,
  506.                      ResourceBundleCache* someCache);
  507.  
  508.     static const UHashtable* getFromCacheWithFallback(const PathInfo& path,
  509.                                                      const UnicodeString& desiredLocale,
  510.                                                      UnicodeString& returnedLocale,
  511.                              ResourceBundleCache* someCache,
  512.                                                      UErrorCode& error);
  513.  
  514.     /**
  515.      * Handlers which are passed to parse() have this signature.
  516.      */
  517.     typedef void (*Handler)(const UnicodeString& localeName,
  518.                             UHashtable* hashtable,
  519.                             void* context,
  520.                 ResourceBundleCache* someCache);
  521.  
  522.     /**
  523.      * Parse a file, storing the resource data in the cache.
  524.      */
  525.     static void parse(const PathInfo& path, 
  526.               const UnicodeString& localeName,
  527.                       Handler handler,
  528.                       void* context,
  529.               ResourceBundleCache* someCache,
  530.                       UErrorCode &error);
  531.  
  532.     /**
  533.      * If the given file exists and has not been parsed, then parse it (caching the
  534.      * resultant data) and return true.
  535.      */
  536.     static bool_t parseIfUnparsed(const PathInfo& path,
  537.                                 const UnicodeString& locale,
  538.                                 ResourceBundleCache* fCache,
  539.                   VisitedFileCache* vCache,
  540.                   UErrorCode& error);
  541.  
  542.     const UHashtable* getHashtableForLocale(const UnicodeString& localeName,
  543.                                            UnicodeString& returnedLocale,
  544.                                            UErrorCode& err);
  545.  
  546.     const UHashtable* getHashtableForLocale(const UnicodeString& desiredLocale,
  547.                                            UErrorCode& error);
  548.  
  549.     const ResourceBundleData* getDataForTag(const UnicodeString& tag,
  550.                                             UErrorCode& err) const;
  551.  
  552.     void constructForLocale(const PathInfo& path,
  553.                             const Locale& locale,
  554.                             UErrorCode& error);
  555.  
  556.     static void addToCache(const UnicodeString& localeName,
  557.                            UHashtable* hashtable,
  558.                            void* context,
  559.                ResourceBundleCache* someCache);
  560.  
  561.     static void saveCollationHashtable(const UnicodeString& localeName,
  562.                                        UHashtable* hashtable,
  563.                                        void* context,
  564.                        ResourceBundleCache* cache);
  565. private:
  566.     /**
  567.      * This internal class iterates over the fallback and/or default locales. It
  568.      * progresses as follows: Specific: language+country+variant language+country
  569.      * language Default: language+country+variant language+country language Root:
  570.      */
  571.     class LocaleFallbackIterator
  572.     {
  573.     public:
  574.         LocaleFallbackIterator(const UnicodeString& startingLocale,
  575.                                const UnicodeString& root,
  576.                                bool_t useDefaultLocale);
  577.  
  578.         const UnicodeString& getLocale(void) const { return fLocale; }
  579.  
  580.         bool_t nextLocale(UErrorCode& status);
  581.  
  582.     private:
  583.         void chopLocale(void);
  584.  
  585.         UnicodeString fLocale;
  586.         UnicodeString fDefaultLocale;
  587.         UnicodeString fRoot;
  588.         bool_t fUseDefaultLocale;
  589.         bool_t fTriedDefaultLocale;
  590.         bool_t fTriedRoot;
  591.     };
  592.  
  593. private:
  594.     static const char*          kDefaultSuffix;
  595.     static const int32_t        kDefaultSuffixLen;
  596.     static const char*          kDefaultFilename;
  597.     static const char*          kDefaultLocaleName;
  598.     static const char*          kIndexLocaleName;
  599.     static const char*          kIndexFilename;
  600.     static const char*          kIndexTag;
  601.  
  602.     static const char*          kDefaultMinorVersion;
  603.     static const char*          kVersionSeparator;
  604.     static const UnicodeString  kVersionTag;
  605.  
  606.     static ResourceBundleCache* fgUserCache;
  607.     static VisitedFileCache*    fgUserVisitedFiles;
  608.  
  609.     ResourceBundleCache* fgCache;
  610.     VisitedFileCache*    fgVisitedFiles;
  611.  
  612.     /**
  613.      * Data members. The ResourceBundle object is kept lightweight by having the fData[]
  614.      * array entries be non-owned pointers. The cache (fgCache) owns the entries and
  615.      * will delete them at static destruction time.
  616.      */
  617.     PathInfo                fPath;
  618.  
  619.     enum {                  kDataCount = 4 };
  620.     const UHashtable*        fData[kDataCount]; // These aren't const if fIsDataOwned is true
  621.     bool_t                  fLoaded[kDataCount];
  622.     UErrorCode              fDataStatus[kDataCount]; // Returns the appropriate error code for each data table.
  623.     bool_t                  fIsDataOwned;
  624.     UnicodeString           fRealLocaleID;
  625.     LocaleFallbackIterator* fLocaleIterator;
  626.     char*                   fVersionID;
  627. };
  628.  
  629. #endif
  630.