libicu/cts_headers/unifiedcache.h - platform/external/icu - Gitiles

 // © 2016 and later: Unicode, Inc. and others.
 // License & terms of use: http://www.unicode.org/copyright.html
 /*
 ******************************************************************************
 * Copyright (C) 2015, International Business Machines Corporation and
 * others. All Rights Reserved.
 ******************************************************************************
 *
 * File UNIFIEDCACHE.H - The ICU Unified cache.
 ******************************************************************************
 */

 #ifndef __UNIFIED_CACHE_H__
 #define __UNIFIED_CACHE_H__

 #include "utypeinfo.h"  // for 'typeid' to work

 #include "unicode/uobject.h"
 #include "unicode/locid.h"
 #include "sharedobject.h"
 #include "unicode/unistr.h"
 #include "cstring.h"
 #include "ustr_imp.h"

 struct UHashtable;
 struct UHashElement;

 U_NAMESPACE_BEGIN

 class UnifiedCache;

 /**
  * A base class for all cache keys.
  */
 class U_COMMON_API CacheKeyBase : public UObject {
  public:
    CacheKeyBase() : fCreationStatus(U_ZERO_ERROR), fIsMaster(FALSE) {}

    /**
     * Copy constructor. Needed to support cloning.
     */
    CacheKeyBase(const CacheKeyBase &other)
            : UObject(other), fCreationStatus(other.fCreationStatus), fIsMaster(FALSE) { }
    virtual ~CacheKeyBase();

    /**
     * Returns the hash code for this object.
     */
    virtual int32_t hashCode() const = 0;

    /**
     * Clones this object polymorphically. Caller owns returned value.
     */
    virtual CacheKeyBase *clone() const = 0;

    /**
     * Equality operator.
     */
    virtual UBool operator == (const CacheKeyBase &other) const = 0;

    /**
     * Create a new object for this key. Called by cache on cache miss.
     * createObject must add a reference to the object it returns. Note
     * that getting an object from the cache and returning it without calling
     * removeRef on it satisfies this requirement. It can also return NULL
     * and set status to an error.
     *
     * @param creationContext the context in which the object is being
     *                        created. May be NULL.
     * @param status          Implementations can return a failure here.
     *                        In addition, implementations may return a
     *                        non NULL object and set a warning status.
     */
    virtual const SharedObject *createObject(
            const void *creationContext, UErrorCode &status) const = 0;

    /**
     * Writes a description of this key to buffer and returns buffer. Written
     * description is NULL terminated.
     */
    virtual char *writeDescription(char *buffer, int32_t bufSize) const = 0;

    /**
     * Inequality operator.
     */
    UBool operator != (const CacheKeyBase &other) const {
        return !(*this == other);
    }
  private:
    mutable UErrorCode fCreationStatus;
    mutable UBool fIsMaster;
    friend class UnifiedCache;
 };


 /**
  * Templated version of CacheKeyBase.
  * A key of type LocaleCacheKey<T> maps to a value of type T.
  */
 template<typename T>
 class CacheKey : public CacheKeyBase {
  public:
    virtual ~CacheKey() { }
    /**
     * The template parameter, T, determines the hash code returned.
     */
    virtual int32_t hashCode() const {
        const char *s = typeid(T).name();
        return ustr_hashCharsN(s, static_cast<int32_t>(uprv_strlen(s)));
    }

    /**
     * Use the value type, T,  as the description.
     */
    virtual char *writeDescription(char *buffer, int32_t bufLen) const {
        const char *s = typeid(T).name();
        uprv_strncpy(buffer, s, bufLen);
        buffer[bufLen - 1] = 0;
        return buffer;
    }

    /**
     * Two objects are equal if they are of the same type.
     */
    virtual UBool operator == (const CacheKeyBase &other) const {
        return typeid(*this) == typeid(other);
    }
 };

 /**
  * Cache key based on locale.
  * A key of type LocaleCacheKey<T> maps to a value of type T.
  */
 template<typename T>
 class LocaleCacheKey : public CacheKey<T> {
  protected:
    Locale   fLoc;
  public:
    LocaleCacheKey(const Locale &loc) : fLoc(loc) {}
    LocaleCacheKey(const LocaleCacheKey<T> &other)
            : CacheKey<T>(other), fLoc(other.fLoc) { }
    virtual ~LocaleCacheKey() { }
    virtual int32_t hashCode() const {
        return (int32_t)(37u * (uint32_t)CacheKey<T>::hashCode() + (uint32_t)fLoc.hashCode());
    }
    virtual UBool operator == (const CacheKeyBase &other) const {
        // reflexive
        if (this == &other) {
            return TRUE;
        }
        if (!CacheKey<T>::operator == (other)) {
            return FALSE;
        }
        // We know this and other are of same class because operator== on
        // CacheKey returned true.
        const LocaleCacheKey<T> *fOther =
                static_cast<const LocaleCacheKey<T> *>(&other);
        return fLoc == fOther->fLoc;
    }
    virtual CacheKeyBase *clone() const {
        return new LocaleCacheKey<T>(*this);
    }
    virtual const T *createObject(
            const void *creationContext, UErrorCode &status) const;
    /**
     * Use the locale id as the description.
     */
    virtual char *writeDescription(char *buffer, int32_t bufLen) const {
        const char *s = fLoc.getName();
        uprv_strncpy(buffer, s, bufLen);
        buffer[bufLen - 1] = 0;
        return buffer;
    }

 };

 /**
  * The unified cache. A singleton type.
  * Design doc here:
  * https://docs.google.com/document/d/1RwGQJs4N4tawNbf809iYDRCvXoMKqDJihxzYt1ysmd8/edit?usp=sharing
  */
 class U_COMMON_API UnifiedCache : public UnifiedCacheBase {
  public:
    /**
     * @internal
     * Do not call directly. Instead use UnifiedCache::getInstance() as
     * there should be only one UnifiedCache in an application.
     */
    UnifiedCache(UErrorCode &status);

    /**
     * Return a pointer to the global cache instance.
     */
    static UnifiedCache *getInstance(UErrorCode &status);

    /**
     * Fetches a value from the cache by key. Equivalent to
     * get(key, NULL, ptr, status);
     */
    template<typename T>
    void get(
            const CacheKey<T>& key,
            const T *&ptr,
            UErrorCode &status) const {
        get(key, NULL, ptr, status);
    }

    /**
     * Fetches value from the cache by key.
     *
     * @param key             the cache key.
     * @param creationContext passed verbatim to createObject method of key
     * @param ptr             On entry, ptr must be NULL or be included if
     *                        the reference count of the object it points
     *                        to. On exit, ptr points to the fetched object
     *                        from the cache or is left unchanged on
     *                        failure. Caller must call removeRef on ptr
     *                        if set to a non NULL value.
     * @param status          Any error returned here. May be set to a
     *                        warning value even if ptr is set.
     */
    template<typename T>
    void get(
            const CacheKey<T>& key,
            const void *creationContext,
            const T *&ptr,
            UErrorCode &status) const {
        if (U_FAILURE(status)) {
            return;
        }
        UErrorCode creationStatus = U_ZERO_ERROR;
        const SharedObject *value = NULL;
        _get(key, value, creationContext, creationStatus);
        const T *tvalue = (const T *) value;
        if (U_SUCCESS(creationStatus)) {
            SharedObject::copyPtr(tvalue, ptr);
        }
        SharedObject::clearPtr(tvalue);
        // Take care not to overwrite a warning status passed in with
        // another warning or U_ZERO_ERROR.
        if (status == U_ZERO_ERROR || U_FAILURE(creationStatus)) {
            status = creationStatus;
        }
    }

 #ifdef UNIFIED_CACHE_DEBUG
    /**
     * Dumps the contents of this cache to standard error. Used for testing of
     * cache only.
     */
    void dumpContents() const;
 #endif

    /**
     * Convenience method to get a value of type T from cache for a
     * particular locale with creationContext == NULL.
     * @param loc    the locale
     * @param ptr    On entry, must be NULL or included in the ref count
     *               of the object to which it points.
     *               On exit, fetched value stored here or is left
     *               unchanged on failure. Caller must call removeRef on
     *               ptr if set to a non NULL value.
     * @param status Any error returned here. May be set to a
     *               warning value even if ptr is set.
     */
    template<typename T>
    static void getByLocale(
            const Locale &loc, const T *&ptr, UErrorCode &status) {
        const UnifiedCache *cache = getInstance(status);
        if (U_FAILURE(status)) {
            return;
        }
        cache->get(LocaleCacheKey<T>(loc), ptr, status);
    }

 #ifdef UNIFIED_CACHE_DEBUG
    /**
     * Dumps the cache contents to stderr. For testing only.
     */
    static void dump();
 #endif

    /**
     * Returns the number of keys in this cache. For testing only.
     */
    int32_t keyCount() const;

    /**
     * Removes any values from cache that are not referenced outside
     * the cache.
     */
    void flush() const;

    /**
     * Configures at what point evcition of unused entries will begin.
     * Eviction is triggered whenever the number of evictable keys exeeds
     * BOTH count AND (number of in-use items) * (percentageOfInUseItems / 100).
     * Once the number of unused entries drops below one of these,
     * eviction ceases. Because eviction happens incrementally,
     * the actual unused entry count may exceed both these numbers
     * from time to time.
     *
     * A cache entry is defined as unused if it is not essential to guarantee
     * that for a given key X, the cache returns the same reference to the
     * same value as long as the client already holds a reference to that
     * value.
     *
     * If this method is never called, the default settings are 1000 and 100%.
     *
     * Although this method is thread-safe, it is designed to be called at
     * application startup. If it is called in the middle of execution, it
     * will have no immediate effect on the cache. However over time, the
     * cache will perform eviction slices in an attempt to honor the new
     * settings.
     *
     * If a client already holds references to many different unique values
     * in the cache such that the number of those unique values far exeeds
     * "count" then the cache may not be able to maintain this maximum.
     * However, if this happens, the cache still guarantees that the number of
     * unused entries will remain only a small percentage of the total cache
     * size.
     *
     * If the parameters passed are negative, setEvctionPolicy sets status to
     * U_ILLEGAL_ARGUMENT_ERROR.
     */
    void setEvictionPolicy(
            int32_t count, int32_t percentageOfInUseItems, UErrorCode &status);


    /**
     * Returns how many entries have been auto evicted during the lifetime
     * of this cache. This only includes auto evicted entries, not
     * entries evicted because of a call to flush().
     */
    int64_t autoEvictedCount() const;

    /**
     * Returns the unused entry count in this cache. For testing only,
     * Regular clients will not need this.
     */
    int32_t unusedCount() const;

    virtual void handleUnreferencedObject() const;
    virtual ~UnifiedCache();

  private:
    UHashtable *fHashtable;
    mutable int32_t fEvictPos;
    mutable int32_t fNumValuesTotal;
    mutable int32_t fNumValuesInUse;
    int32_t fMaxUnused;
    int32_t fMaxPercentageOfInUse;
    mutable int64_t fAutoEvictedCount;
    SharedObject *fNoValue;

    UnifiedCache(const UnifiedCache &other);
    UnifiedCache &operator=(const UnifiedCache &other);

    /**
     * Flushes the contents of the cache. If cache values hold references to other
     * cache values then _flush should be called in a loop until it returns FALSE.
     *
     * On entry, gCacheMutex must be held.
     * On exit, those values with are evictable are flushed.
     *
     *  @param all if false flush evictable items only, which are those with no external
     *                    references, plus those that can be safely recreated.<br>
     *            if true, flush all elements. Any values (sharedObjects) with remaining
     *                     hard (external) references are not deleted, but are detached from
     *                     the cache, so that a subsequent removeRefs can delete them.
     *                     _flush is not thread safe when all is true.
     *   @return TRUE if any value in cache was flushed or FALSE otherwise.
     */
    UBool _flush(UBool all) const;

    /**
     * Gets value out of cache.
     * On entry. gCacheMutex must not be held. value must be NULL. status
     * must be U_ZERO_ERROR.
     * On exit. value and status set to what is in cache at key or on cache
     * miss the key's createObject() is called and value and status are set to
     * the result of that. In this latter case, best effort is made to add the
     * value and status to the cache. If createObject() fails to create a value,
     * fNoValue is stored in cache, and value is set to NULL. Caller must call
     * removeRef on value if non NULL.
     */
    void _get(
            const CacheKeyBase &key,
            const SharedObject *&value,
            const void *creationContext,
            UErrorCode &status) const;

     /**
      * Attempts to fetch value and status for key from cache.
      * On entry, gCacheMutex must not be held value must be NULL and status must
      * be U_ZERO_ERROR.
      * On exit, either returns FALSE (In this
      * case caller should try to create the object) or returns TRUE with value
      * pointing to the fetched value and status set to fetched status. When
      * FALSE is returned status may be set to failure if an in progress hash
      * entry could not be made but value will remain unchanged. When TRUE is
      * returned, caller must call removeRef() on value.
      */
     UBool _poll(
             const CacheKeyBase &key,
             const SharedObject *&value,
             UErrorCode &status) const;

     /**
      * Places a new value and creationStatus in the cache for the given key.
      * On entry, gCacheMutex must be held. key must not exist in the cache.
      * On exit, value and creation status placed under key. Soft reference added
      * to value on successful add. On error sets status.
      */
     void _putNew(
         const CacheKeyBase &key,
         const SharedObject *value,
         const UErrorCode creationStatus,
         UErrorCode &status) const;

     /**
      * Places value and status at key if there is no value at key or if cache
      * entry for key is in progress. Otherwise, it leaves the current value and
      * status there.
      *
      * On entry. gCacheMutex must not be held. Value must be
      * included in the reference count of the object to which it points.
      *
      * On exit, value and status are changed to what was already in the cache if
      * something was there and not in progress. Otherwise, value and status are left
      * unchanged in which case they are placed in the cache on a best-effort basis.
      * Caller must call removeRef() on value.
      */
    void _putIfAbsentAndGet(
            const CacheKeyBase &key,
            const SharedObject *&value,
            UErrorCode &status) const;

     /**
      * Returns the next element in the cache round robin style.
      * Returns nullptr if the cache is empty.
      * On entry, gCacheMutex must be held.
      */
     const UHashElement *_nextElement() const;

    /**
     * Return the number of cache items that would need to be evicted
     * to bring usage into conformance with eviction policy.
     *
     * An item corresponds to an entry in the hash table, a hash table element.
     *
     * On entry, gCacheMutex must be held.
     */
    int32_t _computeCountOfItemsToEvict() const;

    /**
     * Run an eviction slice.
     * On entry, gCacheMutex must be held.
     * _runEvictionSlice runs a slice of the evict pipeline by examining the next
     * 10 entries in the cache round robin style evicting them if they are eligible.
     */
    void _runEvictionSlice() const;

    /**
     * Register a master cache entry. A master key is the first key to create
     * a given  SharedObject value. Subsequent keys whose create function
     * produce referneces to an already existing SharedObject are not masters -
     * they can be evicted and subsequently recreated.
     *
     * On entry, gCacheMutex must be held.
     * On exit, items in use count incremented, entry is marked as a master
     * entry, and value registered with cache so that subsequent calls to
     * addRef() and removeRef() on it correctly interact with the cache.
     */
    void _registerMaster(const CacheKeyBase *theKey, const SharedObject *value) const;

    /**
     * Store a value and creation error status in given hash entry.
     * On entry, gCacheMutex must be held. Hash entry element must be in progress.
     * value must be non NULL.
     * On Exit, soft reference added to value. value and status stored in hash
     * entry. Soft reference removed from previous stored value. Waiting
     * threads notified.
     */
    void _put(
            const UHashElement *element,
            const SharedObject *value,
            const UErrorCode status) const;
     /**
      * Remove a soft reference, and delete the SharedObject if no references remain.
      * To be used from within the UnifiedCache implementation only.
      * gCacheMutex must be held by caller.
      * @param value the SharedObject to be acted on.
      */
    void removeSoftRef(const SharedObject *value) const;

    /**
     * Increment the hard reference count of the given SharedObject.
     * gCacheMutex must be held by the caller.
     * Update numValuesEvictable on transitions between zero and one reference.
     *
     * @param value The SharedObject to be referenced.
     * @return the hard reference count after the addition.
     */
    int32_t addHardRef(const SharedObject *value) const;

   /**
     * Decrement the hard reference count of the given SharedObject.
     * gCacheMutex must be held by the caller.
     * Update numValuesEvictable on transitions between one and zero reference.
     *
     * @param value The SharedObject to be referenced.
     * @return the hard reference count after the removal.
     */
    int32_t removeHardRef(const SharedObject *value) const;


 #ifdef UNIFIED_CACHE_DEBUG
    void _dumpContents() const;
 #endif

    /**
     *  Fetch value and error code from a particular hash entry.
     *  On entry, gCacheMutex must be held. value must be either NULL or must be
     *  included in the ref count of the object to which it points.
     *  On exit, value and status set to what is in the hash entry. Caller must
     *  eventually call removeRef on value.
     *  If hash entry is in progress, value will be set to gNoValue and status will
     *  be set to U_ZERO_ERROR.
     */
    void _fetch(const UHashElement *element, const SharedObject *&value,
                        UErrorCode &status) const;

     /**
      * Determine if given hash entry is in progress.
      * On entry, gCacheMutex must be held.
      */
    UBool _inProgress(const UHashElement *element) const;

    /**
     * Determine if given hash entry is in progress.
     * On entry, gCacheMutex must be held.
     */
    UBool _inProgress(const SharedObject *theValue, UErrorCode creationStatus) const;

    /**
     * Determine if given hash entry is eligible for eviction.
     * On entry, gCacheMutex must be held.
     */
    UBool _isEvictable(const UHashElement *element) const;
 };

 U_NAMESPACE_END

 #endif
	// © 2016 and later: Unicode, Inc. and others.
	// License & terms of use: http://www.unicode.org/copyright.html
	/*
	******************************************************************************
	* Copyright (C) 2015, International Business Machines Corporation and
	* others. All Rights Reserved.
	******************************************************************************
	*
	* File UNIFIEDCACHE.H - The ICU Unified cache.
	******************************************************************************
	*/

	#ifndef __UNIFIED_CACHE_H__
	#define __UNIFIED_CACHE_H__

	#include "utypeinfo.h" // for 'typeid' to work

	#include "unicode/uobject.h"
	#include "unicode/locid.h"
	#include "sharedobject.h"
	#include "unicode/unistr.h"
	#include "cstring.h"
	#include "ustr_imp.h"

	struct UHashtable;
	struct UHashElement;

	U_NAMESPACE_BEGIN

	class UnifiedCache;

	/**
	* A base class for all cache keys.
	*/
	class U_COMMON_API CacheKeyBase : public UObject {
	public:
	CacheKeyBase() : fCreationStatus(U_ZERO_ERROR), fIsMaster(FALSE) {}

	/**
	* Copy constructor. Needed to support cloning.
	*/
	CacheKeyBase(const CacheKeyBase &other)
	: UObject(other), fCreationStatus(other.fCreationStatus), fIsMaster(FALSE) { }
	virtual ~CacheKeyBase();

	/**
	* Returns the hash code for this object.
	*/
	virtual int32_t hashCode() const = 0;

	/**
	* Clones this object polymorphically. Caller owns returned value.
	*/
	virtual CacheKeyBase *clone() const = 0;

	/**
	* Equality operator.
	*/
	virtual UBool operator == (const CacheKeyBase &other) const = 0;

	/**
	* Create a new object for this key. Called by cache on cache miss.
	* createObject must add a reference to the object it returns. Note
	* that getting an object from the cache and returning it without calling
	* removeRef on it satisfies this requirement. It can also return NULL
	* and set status to an error.
	*
	* @param creationContext the context in which the object is being
	* created. May be NULL.
	* @param status Implementations can return a failure here.
	* In addition, implementations may return a
	* non NULL object and set a warning status.
	*/
	virtual const SharedObject *createObject(
	const void *creationContext, UErrorCode &status) const = 0;

	/**
	* Writes a description of this key to buffer and returns buffer. Written
	* description is NULL terminated.
	*/
	virtual char writeDescription(char buffer, int32_t bufSize) const = 0;

	/**
	* Inequality operator.
	*/
	UBool operator != (const CacheKeyBase &other) const {
	return !(*this == other);
	}
	private:
	mutable UErrorCode fCreationStatus;
	mutable UBool fIsMaster;
	friend class UnifiedCache;
	};



	/**
	* Templated version of CacheKeyBase.
	* A key of type LocaleCacheKey<T> maps to a value of type T.
	*/
	template<typename T>
	class CacheKey : public CacheKeyBase {
	public:
	virtual ~CacheKey() { }
	/**
	* The template parameter, T, determines the hash code returned.
	*/
	virtual int32_t hashCode() const {
	const char *s = typeid(T).name();
	return ustr_hashCharsN(s, static_cast<int32_t>(uprv_strlen(s)));
	}

	/**
	* Use the value type, T, as the description.
	*/
	virtual char writeDescription(char buffer, int32_t bufLen) const {
	const char *s = typeid(T).name();
	uprv_strncpy(buffer, s, bufLen);
	buffer[bufLen - 1] = 0;
	return buffer;
	}

	/**
	* Two objects are equal if they are of the same type.
	*/
	virtual UBool operator == (const CacheKeyBase &other) const {
	return typeid(*this) == typeid(other);
	}
	};

	/**
	* Cache key based on locale.
	* A key of type LocaleCacheKey<T> maps to a value of type T.
	*/
	template<typename T>
	class LocaleCacheKey : public CacheKey<T> {
	protected:
	Locale fLoc;
	public:
	LocaleCacheKey(const Locale &loc) : fLoc(loc) {}
	LocaleCacheKey(const LocaleCacheKey<T> &other)
	: CacheKey<T>(other), fLoc(other.fLoc) { }
	virtual ~LocaleCacheKey() { }
	virtual int32_t hashCode() const {
	return (int32_t)(37u * (uint32_t)CacheKey<T>::hashCode() + (uint32_t)fLoc.hashCode());
	}
	virtual UBool operator == (const CacheKeyBase &other) const {
	// reflexive
	if (this == &other) {
	return TRUE;
	}
	if (!CacheKey<T>::operator == (other)) {
	return FALSE;
	}
	// We know this and other are of same class because operator== on
	// CacheKey returned true.
	const LocaleCacheKey<T> *fOther =
	static_cast<const LocaleCacheKey<T> *>(&other);
	return fLoc == fOther->fLoc;
	}
	virtual CacheKeyBase *clone() const {
	return new LocaleCacheKey<T>(*this);
	}
	virtual const T *createObject(
	const void *creationContext, UErrorCode &status) const;
	/**
	* Use the locale id as the description.
	*/
	virtual char writeDescription(char buffer, int32_t bufLen) const {
	const char *s = fLoc.getName();
	uprv_strncpy(buffer, s, bufLen);
	buffer[bufLen - 1] = 0;
	return buffer;
	}

	};

	/**
	* The unified cache. A singleton type.
	* Design doc here:
	* https://docs.google.com/document/d/1RwGQJs4N4tawNbf809iYDRCvXoMKqDJihxzYt1ysmd8/edit?usp=sharing
	*/
	class U_COMMON_API UnifiedCache : public UnifiedCacheBase {
	public:
	/**
	* @internal
	* Do not call directly. Instead use UnifiedCache::getInstance() as
	* there should be only one UnifiedCache in an application.
	*/
	UnifiedCache(UErrorCode &status);

	/**
	* Return a pointer to the global cache instance.
	*/
	static UnifiedCache *getInstance(UErrorCode &status);

	/**
	* Fetches a value from the cache by key. Equivalent to
	* get(key, NULL, ptr, status);
	*/
	template<typename T>
	void get(
	const CacheKey<T>& key,
	const T *&ptr,
	UErrorCode &status) const {
	get(key, NULL, ptr, status);
	}

	/**
	* Fetches value from the cache by key.
	*
	* @param key the cache key.
	* @param creationContext passed verbatim to createObject method of key
	* @param ptr On entry, ptr must be NULL or be included if
	* the reference count of the object it points
	* to. On exit, ptr points to the fetched object
	* from the cache or is left unchanged on
	* failure. Caller must call removeRef on ptr
	* if set to a non NULL value.
	* @param status Any error returned here. May be set to a
	* warning value even if ptr is set.
	*/
	template<typename T>
	void get(
	const CacheKey<T>& key,
	const void *creationContext,
	const T *&ptr,
	UErrorCode &status) const {
	if (U_FAILURE(status)) {
	return;
	}
	UErrorCode creationStatus = U_ZERO_ERROR;
	const SharedObject *value = NULL;
	_get(key, value, creationContext, creationStatus);
	const T tvalue = (const T ) value;
	if (U_SUCCESS(creationStatus)) {
	SharedObject::copyPtr(tvalue, ptr);
	}
	SharedObject::clearPtr(tvalue);
	// Take care not to overwrite a warning status passed in with
	// another warning or U_ZERO_ERROR.
	if (status == U_ZERO_ERROR \|\| U_FAILURE(creationStatus)) {
	status = creationStatus;
	}
	}

	#ifdef UNIFIED_CACHE_DEBUG
	/**
	* Dumps the contents of this cache to standard error. Used for testing of
	* cache only.
	*/
	void dumpContents() const;
	#endif

	/**
	* Convenience method to get a value of type T from cache for a
	* particular locale with creationContext == NULL.
	* @param loc the locale
	* @param ptr On entry, must be NULL or included in the ref count
	* of the object to which it points.
	* On exit, fetched value stored here or is left
	* unchanged on failure. Caller must call removeRef on
	* ptr if set to a non NULL value.
	* @param status Any error returned here. May be set to a
	* warning value even if ptr is set.
	*/
	template<typename T>
	static void getByLocale(
	const Locale &loc, const T *&ptr, UErrorCode &status) {
	const UnifiedCache *cache = getInstance(status);
	if (U_FAILURE(status)) {
	return;
	}
	cache->get(LocaleCacheKey<T>(loc), ptr, status);
	}

	#ifdef UNIFIED_CACHE_DEBUG
	/**
	* Dumps the cache contents to stderr. For testing only.
	*/
	static void dump();
	#endif

	/**
	* Returns the number of keys in this cache. For testing only.
	*/
	int32_t keyCount() const;

	/**
	* Removes any values from cache that are not referenced outside
	* the cache.
	*/
	void flush() const;

	/**
	* Configures at what point evcition of unused entries will begin.
	* Eviction is triggered whenever the number of evictable keys exeeds
	* BOTH count AND (number of in-use items) * (percentageOfInUseItems / 100).
	* Once the number of unused entries drops below one of these,
	* eviction ceases. Because eviction happens incrementally,
	* the actual unused entry count may exceed both these numbers
	* from time to time.
	*
	* A cache entry is defined as unused if it is not essential to guarantee
	* that for a given key X, the cache returns the same reference to the
	* same value as long as the client already holds a reference to that
	* value.
	*
	* If this method is never called, the default settings are 1000 and 100%.
	*
	* Although this method is thread-safe, it is designed to be called at
	* application startup. If it is called in the middle of execution, it
	* will have no immediate effect on the cache. However over time, the
	* cache will perform eviction slices in an attempt to honor the new
	* settings.
	*
	* If a client already holds references to many different unique values
	* in the cache such that the number of those unique values far exeeds
	* "count" then the cache may not be able to maintain this maximum.
	* However, if this happens, the cache still guarantees that the number of
	* unused entries will remain only a small percentage of the total cache
	* size.
	*
	* If the parameters passed are negative, setEvctionPolicy sets status to
	* U_ILLEGAL_ARGUMENT_ERROR.
	*/
	void setEvictionPolicy(
	int32_t count, int32_t percentageOfInUseItems, UErrorCode &status);


	/**
	* Returns how many entries have been auto evicted during the lifetime
	* of this cache. This only includes auto evicted entries, not
	* entries evicted because of a call to flush().
	*/
	int64_t autoEvictedCount() const;

	/**
	* Returns the unused entry count in this cache. For testing only,
	* Regular clients will not need this.
	*/
	int32_t unusedCount() const;

	virtual void handleUnreferencedObject() const;
	virtual ~UnifiedCache();

	private:
	UHashtable *fHashtable;
	mutable int32_t fEvictPos;
	mutable int32_t fNumValuesTotal;
	mutable int32_t fNumValuesInUse;
	int32_t fMaxUnused;
	int32_t fMaxPercentageOfInUse;
	mutable int64_t fAutoEvictedCount;
	SharedObject *fNoValue;

	UnifiedCache(const UnifiedCache &other);
	UnifiedCache &operator=(const UnifiedCache &other);

	/**
	* Flushes the contents of the cache. If cache values hold references to other
	* cache values then _flush should be called in a loop until it returns FALSE.
	*
	* On entry, gCacheMutex must be held.
	* On exit, those values with are evictable are flushed.
	*
	* @param all if false flush evictable items only, which are those with no external
	* references, plus those that can be safely recreated.<br>
	* if true, flush all elements. Any values (sharedObjects) with remaining
	* hard (external) references are not deleted, but are detached from
	* the cache, so that a subsequent removeRefs can delete them.
	* _flush is not thread safe when all is true.
	* @return TRUE if any value in cache was flushed or FALSE otherwise.
	*/
	UBool _flush(UBool all) const;

	/**
	* Gets value out of cache.
	* On entry. gCacheMutex must not be held. value must be NULL. status
	* must be U_ZERO_ERROR.
	* On exit. value and status set to what is in cache at key or on cache
	* miss the key's createObject() is called and value and status are set to
	* the result of that. In this latter case, best effort is made to add the
	* value and status to the cache. If createObject() fails to create a value,
	* fNoValue is stored in cache, and value is set to NULL. Caller must call
	* removeRef on value if non NULL.
	*/
	void _get(
	const CacheKeyBase &key,
	const SharedObject *&value,
	const void *creationContext,
	UErrorCode &status) const;

	/**
	* Attempts to fetch value and status for key from cache.
	* On entry, gCacheMutex must not be held value must be NULL and status must
	* be U_ZERO_ERROR.
	* On exit, either returns FALSE (In this
	* case caller should try to create the object) or returns TRUE with value
	* pointing to the fetched value and status set to fetched status. When
	* FALSE is returned status may be set to failure if an in progress hash
	* entry could not be made but value will remain unchanged. When TRUE is
	* returned, caller must call removeRef() on value.
	*/
	UBool _poll(
	const CacheKeyBase &key,
	const SharedObject *&value,
	UErrorCode &status) const;

	/**
	* Places a new value and creationStatus in the cache for the given key.
	* On entry, gCacheMutex must be held. key must not exist in the cache.
	* On exit, value and creation status placed under key. Soft reference added
	* to value on successful add. On error sets status.
	*/
	void _putNew(
	const CacheKeyBase &key,
	const SharedObject *value,
	const UErrorCode creationStatus,
	UErrorCode &status) const;

	/**
	* Places value and status at key if there is no value at key or if cache
	* entry for key is in progress. Otherwise, it leaves the current value and
	* status there.
	*
	* On entry. gCacheMutex must not be held. Value must be
	* included in the reference count of the object to which it points.
	*
	* On exit, value and status are changed to what was already in the cache if
	* something was there and not in progress. Otherwise, value and status are left
	* unchanged in which case they are placed in the cache on a best-effort basis.
	* Caller must call removeRef() on value.
	*/
	void _putIfAbsentAndGet(
	const CacheKeyBase &key,
	const SharedObject *&value,
	UErrorCode &status) const;

	/**
	* Returns the next element in the cache round robin style.
	* Returns nullptr if the cache is empty.
	* On entry, gCacheMutex must be held.
	*/
	const UHashElement *_nextElement() const;

	/**
	* Return the number of cache items that would need to be evicted
	* to bring usage into conformance with eviction policy.
	*
	* An item corresponds to an entry in the hash table, a hash table element.
	*
	* On entry, gCacheMutex must be held.
	*/
	int32_t _computeCountOfItemsToEvict() const;

	/**
	* Run an eviction slice.
	* On entry, gCacheMutex must be held.
	* _runEvictionSlice runs a slice of the evict pipeline by examining the next
	* 10 entries in the cache round robin style evicting them if they are eligible.
	*/
	void _runEvictionSlice() const;

	/**
	* Register a master cache entry. A master key is the first key to create
	* a given SharedObject value. Subsequent keys whose create function
	* produce referneces to an already existing SharedObject are not masters -
	* they can be evicted and subsequently recreated.
	*
	* On entry, gCacheMutex must be held.
	* On exit, items in use count incremented, entry is marked as a master
	* entry, and value registered with cache so that subsequent calls to
	* addRef() and removeRef() on it correctly interact with the cache.
	*/
	void _registerMaster(const CacheKeyBase theKey, const SharedObject value) const;

	/**
	* Store a value and creation error status in given hash entry.
	* On entry, gCacheMutex must be held. Hash entry element must be in progress.
	* value must be non NULL.
	* On Exit, soft reference added to value. value and status stored in hash
	* entry. Soft reference removed from previous stored value. Waiting
	* threads notified.
	*/
	void _put(
	const UHashElement *element,
	const SharedObject *value,
	const UErrorCode status) const;
	/**
	* Remove a soft reference, and delete the SharedObject if no references remain.
	* To be used from within the UnifiedCache implementation only.
	* gCacheMutex must be held by caller.
	* @param value the SharedObject to be acted on.
	*/
	void removeSoftRef(const SharedObject *value) const;

	/**
	* Increment the hard reference count of the given SharedObject.
	* gCacheMutex must be held by the caller.
	* Update numValuesEvictable on transitions between zero and one reference.
	*
	* @param value The SharedObject to be referenced.
	* @return the hard reference count after the addition.
	*/
	int32_t addHardRef(const SharedObject *value) const;

	/**
	* Decrement the hard reference count of the given SharedObject.
	* gCacheMutex must be held by the caller.
	* Update numValuesEvictable on transitions between one and zero reference.
	*
	* @param value The SharedObject to be referenced.
	* @return the hard reference count after the removal.
	*/
	int32_t removeHardRef(const SharedObject *value) const;


	#ifdef UNIFIED_CACHE_DEBUG
	void _dumpContents() const;
	#endif

	/**
	* Fetch value and error code from a particular hash entry.
	* On entry, gCacheMutex must be held. value must be either NULL or must be
	* included in the ref count of the object to which it points.
	* On exit, value and status set to what is in the hash entry. Caller must
	* eventually call removeRef on value.
	* If hash entry is in progress, value will be set to gNoValue and status will
	* be set to U_ZERO_ERROR.
	*/
	void _fetch(const UHashElement element, const SharedObject &value,
	UErrorCode &status) const;

	/**
	* Determine if given hash entry is in progress.
	* On entry, gCacheMutex must be held.
	*/
	UBool _inProgress(const UHashElement *element) const;

	/**
	* Determine if given hash entry is in progress.
	* On entry, gCacheMutex must be held.
	*/
	UBool _inProgress(const SharedObject *theValue, UErrorCode creationStatus) const;

	/**
	* Determine if given hash entry is eligible for eviction.
	* On entry, gCacheMutex must be held.
	*/
	UBool _isEvictable(const UHashElement *element) const;
	};

	U_NAMESPACE_END

	#endif