// © 2016 and later: Unicode, Inc. and others.

// License & terms of use: http://www.unicode.org/copyright.html

/*

**********************************************************************

*   Copyright (C) 1997-2013, International Business Machines

*   Corporation and others.  All Rights Reserved.

**********************************************************************

*

* File resbund.cpp

*

* Modification History:

*

*   Date        Name        Description

*   02/05/97    aliu        Fixed bug in chopLocale.  Added scanForLocaleInFile

*                           based on code taken from scanForLocale.  Added

*                           constructor which attempts to read resource bundle

*                           from a specific file, without searching other files.

*   02/11/97    aliu        Added UErrorCode return values to constructors. Fixed

*                           infinite loops in scanForFile and scanForLocale.

*                           Modified getRawResourceData to not delete storage in

*                           localeData and resourceData which it doesn't own.

*                           Added Mac compatibility #ifdefs for tellp() and

*                           ios::nocreate.

*   03/04/97    aliu        Modified to use ExpandingDataSink objects instead of

*                           the highly inefficient ostrstream objects.

*   03/13/97    aliu        Rewrote to load in entire resource bundle and store

*                           it as a Hashtable of ResourceBundleData objects.

*                           Added state table to govern parsing of files.

*                           Modified to load locale index out of new file distinct

*                           from default.txt.

*   03/25/97    aliu        Modified to support 2-d arrays, needed for timezone data.

*                           Added support for custom file suffixes.  Again, needed

*                           to support timezone data.  Improved error handling to

*                           detect duplicate tags and subtags.

*   04/07/97    aliu        Fixed bug in getHashtableForLocale().  Fixed handling

*                           of failing UErrorCode values on entry to API methods.

*                           Fixed bugs in getArrayItem() for negative indices.

*   04/29/97    aliu        Update to use new Hashtable deletion protocol.

*   05/06/97    aliu        Flattened kTransitionTable for HP compiler.

*                           Fixed usage of CharString.

* 06/11/99      stephen     Removed parsing of .txt files.

*                           Reworked to use new binary format.

*                           Cleaned up.

* 06/14/99      stephen     Removed methods taking a filename suffix.

* 06/22/99      stephen     Added missing T_FileStream_close in parse()

* 11/09/99      weiv        Added getLocale(), rewritten constructForLocale()

* March 2000    weiv        complete overhaul.

******************************************************************************

*/

#include "unicode/utypes.h"

#include "unicode/resbund.h"

#include "mutex.h"

#include "uassert.h"

#include "umutex.h"

#include "uresimp.h"

U_NAMESPACE_BEGIN

/*-----------------------------------------------------------------------------

 * Implementation Notes

 *

 * Resource bundles are read in once, and thereafter cached.

 * ResourceBundle statically keeps track of which files have been

 * read, so we are guaranteed that each file is read at most once.

 * Resource bundles can be loaded from different data directories and

 * will be treated as distinct, even if they are for the same locale.

 *

 * Resource bundles are lightweight objects, which have pointers to

 * one or more shared Hashtable objects containing all the data.

 * Copying would be cheap, but there is no copy constructor, since

 * there wasn't one in the original API.

 *

 * The ResourceBundle parsing mechanism is implemented as a transition

 * network, for easy maintenance and modification.  The network is

 * implemented as a matrix (instead of in code) to make this even

 * easier.  The matrix contains Transition objects.  Each Transition

 * object describes a destination node and an action to take before

 * moving to the destination node.  The source node is encoded by the

 * index of the object in the array that contains it.  The pieces

 * needed to understand the transition network are the enums for node

 * IDs and actions, the parse() method, which walks through the

 * network and implements the actions, and the network itself.  The

 * network guarantees certain conditions, for example, that a new

 * resource will not be closed until one has been opened first; or

 * that data will not be stored into a TaggedList until a TaggedList

 * has been created.  Nonetheless, the code in parse() does some

 * consistency checks as it runs the network, and fails with an

 * U_INTERNAL_PROGRAM_ERROR if one of these checks fails.  If the input

 * data has a bad format, an U_INVALID_FORMAT_ERROR is returned.  If you

 * see an U_INTERNAL_PROGRAM_ERROR the transition matrix has a bug in

 * it.

 *

 * Old functionality of multiple locales in a single file is still

 * supported.  For this reason, LOCALE names override FILE names.  If

 * data for en_US is located in the en.txt file, once it is loaded,

 * the code will not care where it came from (other than remembering

 * which directory it came from).  However, if there is an en_US

 * resource in en_US.txt, that will take precedence.  There is no

 * limit to the number or type of resources that can be stored in a

 * file, however, files are only searched in a specific way.  If

 * en_US_CA is requested, then first en_US_CA.txt is searched, then

 * en_US.txt, then en.txt, then default.txt.  So it only makes sense

 * to put certain locales in certain files.  In this example, it would

 * be logical to put en_US_CA, en_US, and en into the en.txt file,

 * since they would be found there if asked for.  The extreme example

 * is to place all locale resources into default.txt, which should

 * also work.

 *

 * Inheritance is implemented.  For example, xx_YY_zz inherits as

 * follows: xx_YY_zz, xx_YY, xx, default.  Inheritance is implemented

 * as an array of hashtables.  There will be from 1 to 4 hashtables in

 * the array.

 *

 * Fallback files are implemented.  The fallback pattern is Language

 * Country Variant (LCV) -> LC -> L.  Fallback is first done for the

 * requested locale.  Then it is done for the default locale, as

 * returned by Locale::getDefault().  Then the special file

 * default.txt is searched for the default locale.  The overall FILE

 * fallback path is LCV -> LC -> L -> dLCV -> dLC -> dL -> default.

 *

 * Note that although file name searching includes the default locale,

 * once a ResourceBundle object is constructed, the inheritance path

 * no longer includes the default locale.  The path is LCV -> LC -> L

 * -> default.

 *

 * File parsing is lazy.  Nothing is parsed unless it is called for by

 * someone.  So when a ResourceBundle for xx_YY_zz is constructed,

 * only that locale is parsed (along with anything else in the same

 * file).  Later, if the FooBar tag is asked for, and if it isn't

 * found in xx_YY_zz, then xx_YY.txt will be parsed and checked, and

 * so forth, until the chain is exhausted or the tag is found.

 *

 * Thread-safety is implemented around caches, both the cache that

 * stores all the resouce data, and the cache that stores flags

 * indicating whether or not a file has been visited.  These caches

 * delete their storage at static cleanup time, when the process

 * quits.

 *

 * ResourceBundle supports TableCollation as a special case.  This

 * involves having special ResourceBundle objects which DO own their

 * data, since we don't want large collation rule strings in the

 * ResourceBundle cache (these are already cached in the

 * TableCollation cache).  TableCollation files (.ctx files) have the

 * same format as normal resource data files, with a different

 * interpretation, from the standpoint of ResourceBundle.  .ctx files

 * are loaded into otherwise ordinary ResourceBundle objects.  They

 * don't inherit (that's implemented by TableCollation) and they own

 * their data (as mentioned above).  However, they still support

 * possible multiple locales in a single .ctx file.  (This is in

 * practice a bad idea, since you only want the one locale you're

 * looking for, and only one tag will be present

 * ("CollationElements"), so you don't need an inheritance chain of

 * multiple locales.)  Up to 4 locale resources will be loaded from a

 * .ctx file; everything after the first 4 is ignored (parsed and

 * deleted).  (Normal .txt files have no limit.)  Instead of being

 * loaded into the cache, and then looked up as needed, the locale

 * resources are read straight into the ResourceBundle object.

 *

 * The Index, which used to reside in default.txt, has been moved to a

 * new file, index.txt.  This file contains a slightly modified format

 * with the addition of the "InstalledLocales" tag; it looks like:

 *

 * Index {

 *   InstalledLocales {

 *     ar

 *     ..

 *     zh_TW

 *   }

 * }

 */

//-----------------------------------------------------------------------------

UOBJECT_DEFINE_RTTI_IMPLEMENTATION(ResourceBundle)

ResourceBundle::ResourceBundle(UErrorCode &err)

                                :UObject(), fLocale(NULL)

{

    fResource = ures_open(0, Locale::getDefault().getName(), &err);

}

ResourceBundle::ResourceBundle(const ResourceBundle &other)

                              :UObject(other), fLocale(NULL)

{

    UErrorCode status = U_ZERO_ERROR;

    if (other.fResource) {

        fResource = ures_copyResb(0, other.fResource, &status);

    } else {

        /* Copying a bad resource bundle */

        fResource = NULL;

    }

}

ResourceBundle::ResourceBundle(UResourceBundle *res, UErrorCode& err)

                               :UObject(), fLocale(NULL)

{

    if (res) {

        fResource = ures_copyResb(0, res, &err);

    } else {

        /* Copying a bad resource bundle */

        fResource = NULL;

    }

}

ResourceBundle::ResourceBundle(const char* path, const Locale& locale, UErrorCode& err) 

                               :UObject(), fLocale(NULL)

{

    fResource = ures_open(path, locale.getName(), &err);

}

ResourceBundle& ResourceBundle::operator=(const ResourceBundle& other)

{

    if(this == &other) {

        return *this;

    }

    if(fResource != 0) {

        ures_close(fResource);

        fResource = NULL;

    }

    if (fLocale != NULL) {

        delete fLocale;

        fLocale = NULL;

    }

    UErrorCode status = U_ZERO_ERROR;

    if (other.fResource) {

        fResource = ures_copyResb(0, other.fResource, &status);

    } else {

        /* Copying a bad resource bundle */

        fResource = NULL;

    }

    return *this;

}

ResourceBundle::~ResourceBundle()

{

    if(fResource != 0) {

        ures_close(fResource);

    }

    if(fLocale != NULL) {

      delete(fLocale);

    }

}

ResourceBundle *

ResourceBundle::clone() const {

    return new ResourceBundle(*this);

}

UnicodeString ResourceBundle::getString(UErrorCode& status) const {

    int32_t len = 0;

    const UChar *r = ures_getString(fResource, &len, &status);

    return UnicodeString(TRUE, r, len);

}

const uint8_t *ResourceBundle::getBinary(int32_t& len, UErrorCode& status) const {

    return ures_getBinary(fResource, &len, &status);

}

const int32_t *ResourceBundle::getIntVector(int32_t& len, UErrorCode& status) const {

    return ures_getIntVector(fResource, &len, &status);

}

uint32_t ResourceBundle::getUInt(UErrorCode& status) const {

    return ures_getUInt(fResource, &status);

}

int32_t ResourceBundle::getInt(UErrorCode& status) const {

    return ures_getInt(fResource, &status);

}

const char *ResourceBundle::getName(void) const {

    return ures_getName(fResource);

}

const char *ResourceBundle::getKey(void) const {

    return ures_getKey(fResource);

}

UResType ResourceBundle::getType(void) const {

    return ures_getType(fResource);

}

int32_t ResourceBundle::getSize(void) const {

    return ures_getSize(fResource);

}

UBool ResourceBundle::hasNext(void) const {

    return ures_hasNext(fResource);

}

void ResourceBundle::resetIterator(void) {

    ures_resetIterator(fResource);

}

ResourceBundle ResourceBundle::getNext(UErrorCode& status) {

    UResourceBundle r;

    ures_initStackObject(&r);

    ures_getNextResource(fResource, &r, &status);

    ResourceBundle res(&r, status);

    if (U_SUCCESS(status)) {

        ures_close(&r);

    }

    return res;

}

UnicodeString ResourceBundle::getNextString(UErrorCode& status) {

    int32_t len = 0;

    const UChar* r = ures_getNextString(fResource, &len, 0, &status);

    return UnicodeString(TRUE, r, len);

}

UnicodeString ResourceBundle::getNextString(const char ** key, UErrorCode& status) {

    int32_t len = 0;

    const UChar* r = ures_getNextString(fResource, &len, key, &status);

    return UnicodeString(TRUE, r, len);

}

ResourceBundle ResourceBundle::get(int32_t indexR, UErrorCode& status) const {

    UResourceBundle r;

    ures_initStackObject(&r);

    ures_getByIndex(fResource, indexR, &r, &status);

    ResourceBundle res(&r, status);

    if (U_SUCCESS(status)) {

        ures_close(&r);

    }

    return res;

}

UnicodeString ResourceBundle::getStringEx(int32_t indexS, UErrorCode& status) const {

    int32_t len = 0;

    const UChar* r = ures_getStringByIndex(fResource, indexS, &len, &status);

    return UnicodeString(TRUE, r, len);

}

ResourceBundle ResourceBundle::get(const char* key, UErrorCode& status) const {

    UResourceBundle r;

    ures_initStackObject(&r);

    ures_getByKey(fResource, key, &r, &status);

    ResourceBundle res(&r, status);

    if (U_SUCCESS(status)) {

        ures_close(&r);

    }

    return res;

}

ResourceBundle ResourceBundle::getWithFallback(const char* key, UErrorCode& status){

    UResourceBundle r;

    ures_initStackObject(&r);

    ures_getByKeyWithFallback(fResource, key, &r, &status);

    ResourceBundle res(&r, status);

    if(U_SUCCESS(status)){

        ures_close(&r);

    }

    return res;

}

UnicodeString ResourceBundle::getStringEx(const char* key, UErrorCode& status) const {

    int32_t len = 0;

    const UChar* r = ures_getStringByKey(fResource, key, &len, &status);

    return UnicodeString(TRUE, r, len);

}

const char*

ResourceBundle::getVersionNumber()  const

{

    return ures_getVersionNumberInternal(fResource);

}

void ResourceBundle::getVersion(UVersionInfo versionInfo) const {

    ures_getVersion(fResource, versionInfo);

}

static UMutex gLocaleLock = U_MUTEX_INITIALIZER;

const Locale &ResourceBundle::getLocale(void) const {

    Mutex lock(&gLocaleLock);

    if (fLocale != NULL) {

        return *fLocale;

    }

    UErrorCode status = U_ZERO_ERROR;

    const char *localeName = ures_getLocaleInternal(fResource, &status);

    ResourceBundle *ncThis = const_cast<ResourceBundle *>(this);

    ncThis->fLocale = new Locale(localeName);

    return ncThis->fLocale != NULL ? *ncThis->fLocale : Locale::getDefault();

}

const Locale ResourceBundle::getLocale(ULocDataLocaleType type, UErrorCode &status) const

{

  return ures_getLocaleByType(fResource, type, &status);

}

U_NAMESPACE_END

//eof