tor-browser

serv.cpp (26521B)

---

// © 2016 and later: Unicode, Inc. and others.
// License & terms of use: http://www.unicode.org/copyright.html
/**
*******************************************************************************
* Copyright (C) 2001-2014, International Business Machines Corporation.
* All Rights Reserved.
*******************************************************************************
*/

#include "unicode/utypes.h"
#include "unicode/localpointer.h"

#if !UCONFIG_NO_SERVICE

#include "serv.h"
#include "umutex.h"

#undef SERVICE_REFCOUNT

// in case we use the refcount stuff

U_NAMESPACE_BEGIN

/*
******************************************************************
*/

const char16_t ICUServiceKey::PREFIX_DELIMITER = 0x002F;   /* '/' */

ICUServiceKey::ICUServiceKey(const UnicodeString& id) 
: _id(id) {
}

ICUServiceKey::~ICUServiceKey() 
{
}

const UnicodeString& 
ICUServiceKey::getID() const 
{
   return _id;
}

UnicodeString& 
ICUServiceKey::canonicalID(UnicodeString& result) const 
{
   return result.append(_id);
}

UnicodeString& 
ICUServiceKey::currentID(UnicodeString& result) const 
{
   return canonicalID(result);
}

UnicodeString& 
ICUServiceKey::currentDescriptor(UnicodeString& result) const 
{
   prefix(result);
   result.append(PREFIX_DELIMITER);
   return currentID(result);
}

UBool 
ICUServiceKey::fallback() 
{
   return false;
}

UBool 
ICUServiceKey::isFallbackOf(const UnicodeString& id) const 
{
   return id == _id;
}

UnicodeString& 
ICUServiceKey::prefix(UnicodeString& result) const 
{
   return result;
}

UnicodeString& 
ICUServiceKey::parsePrefix(UnicodeString& result) 
{
   int32_t n = result.indexOf(PREFIX_DELIMITER);
   if (n < 0) {
       n = 0;
   }
   result.remove(n);
   return result;
}

UnicodeString& 
ICUServiceKey::parseSuffix(UnicodeString& result) 
{
   int32_t n = result.indexOf(PREFIX_DELIMITER);
   if (n >= 0) {
       result.remove(0, n+1);
   }
   return result;
}

#ifdef SERVICE_DEBUG
UnicodeString& 
ICUServiceKey::debug(UnicodeString& result) const 
{
   debugClass(result);
   result.append((UnicodeString)" id: ");
   result.append(_id);
   return result;
}

UnicodeString& 
ICUServiceKey::debugClass(UnicodeString& result) const 
{
   return result.append((UnicodeString)"ICUServiceKey");
}
#endif

UOBJECT_DEFINE_RTTI_IMPLEMENTATION(ICUServiceKey)

/*
******************************************************************
*/

ICUServiceFactory::~ICUServiceFactory() {}

SimpleFactory::SimpleFactory(UObject* instanceToAdopt, const UnicodeString& id, UBool visible) 
: _instance(instanceToAdopt), _id(id), _visible(visible)
{
}

SimpleFactory::~SimpleFactory() 
{
   delete _instance;
}

UObject* 
SimpleFactory::create(const ICUServiceKey& key, const ICUService* service, UErrorCode& status) const 
{
   if (U_SUCCESS(status)) {
       UnicodeString temp;
       if (_id == key.currentID(temp)) {
           return service->cloneInstance(_instance); 
       }
   }
   return nullptr;
}

void 
SimpleFactory::updateVisibleIDs(Hashtable& result, UErrorCode& status) const 
{
   if (_visible) {
       result.put(_id, (void*)this, status); // cast away const
   } else {
       result.remove(_id);
   }
}

UnicodeString& 
SimpleFactory::getDisplayName(const UnicodeString& id, const Locale& /* locale */, UnicodeString& result) const 
{
   if (_visible && _id == id) {
       result = _id;
   } else {
       result.setToBogus();
   }
   return result;
}

#ifdef SERVICE_DEBUG
UnicodeString& 
SimpleFactory::debug(UnicodeString& toAppendTo) const 
{
   debugClass(toAppendTo);
   toAppendTo.append((UnicodeString)" id: ");
   toAppendTo.append(_id);
   toAppendTo.append((UnicodeString)", visible: ");
   toAppendTo.append(_visible ? (UnicodeString)"T" : (UnicodeString)"F");
   return toAppendTo;
}

UnicodeString& 
SimpleFactory::debugClass(UnicodeString& toAppendTo) const 
{
   return toAppendTo.append((UnicodeString)"SimpleFactory");
}
#endif

UOBJECT_DEFINE_RTTI_IMPLEMENTATION(SimpleFactory)

/*
******************************************************************
*/

ServiceListener::~ServiceListener() {}

UOBJECT_DEFINE_RTTI_IMPLEMENTATION(ServiceListener)

/*
******************************************************************
*/

// Record the actual id for this service in the cache, so we can return it
// even if we succeed later with a different id.
class CacheEntry : public UMemory {
private:
   int32_t refcount;

public:
   UnicodeString actualDescriptor;
   UObject* service;

   /**
   * Releases a reference to the shared resource.
   */
   ~CacheEntry() {
       delete service;
   }

   CacheEntry(const UnicodeString& _actualDescriptor, UObject* _service) 
       : refcount(1), actualDescriptor(_actualDescriptor), service(_service) {
   }

   /**
   * Instantiation creates an initial reference, so don't call this
   * unless you're creating a new pointer to this.  Management of
   * that pointer will have to know how to deal with refcounts.  
   * Return true if the resource has not already been released.
   */
   CacheEntry* ref() {
       ++refcount;
       return this;
   }

   /**
   * Destructions removes a reference, so don't call this unless
   * you're removing pointer to this somewhere.  Management of that
   * pointer will have to know how to deal with refcounts.  Once
   * the refcount drops to zero, the resource is released.  Return
   * false if the resource has been released.
   */
   CacheEntry* unref() {
       if ((--refcount) == 0) {
           delete this;
           return nullptr;
       }
       return this;
   }

   /**
   * Return true if there is at least one reference to this and the
   * resource has not been released.
   */
   UBool isShared() const {
       return refcount > 1;
   }
};

// Deleter for serviceCache
U_CDECL_BEGIN
static void U_CALLCONV
cacheDeleter(void* obj) {
   U_NAMESPACE_USE ((CacheEntry*)obj)->unref();
}

U_CDECL_END

/*
******************************************************************
*/

class DNCache : public UMemory {
public:
   Hashtable cache;
   const Locale locale;

   DNCache(const Locale& _locale) 
       : cache(), locale(_locale) 
   {
       // cache.setKeyDeleter(uprv_deleteUObject);
   }
};


/*
******************************************************************
*/

StringPair* 
StringPair::create(const UnicodeString& displayName, 
                  const UnicodeString& id,
                  UErrorCode& status)
{
   if (U_SUCCESS(status)) {
       StringPair* sp = new StringPair(displayName, id);
       if (sp == nullptr || sp->isBogus()) {
           status = U_MEMORY_ALLOCATION_ERROR;
           delete sp;
           return nullptr;
       }
       return sp;
   }
   return nullptr;
}

UBool 
StringPair::isBogus() const {
   return displayName.isBogus() || id.isBogus();
}

StringPair::StringPair(const UnicodeString& _displayName, 
                      const UnicodeString& _id)
: displayName(_displayName)
, id(_id)
{
}

U_CDECL_BEGIN
static void U_CALLCONV
userv_deleteStringPair(void *obj) {
   U_NAMESPACE_USE delete (StringPair*) obj;
}
U_CDECL_END

/*
******************************************************************
*/

static UMutex lock;

ICUService::ICUService()
: name()
, timestamp(0)
, factories(nullptr)
, serviceCache(nullptr)
, idCache(nullptr)
, dnCache(nullptr)
{
}

ICUService::ICUService(const UnicodeString& newName) 
: name(newName)
, timestamp(0)
, factories(nullptr)
, serviceCache(nullptr)
, idCache(nullptr)
, dnCache(nullptr)
{
}

ICUService::~ICUService()
{
   {
       Mutex mutex(&lock);
       clearCaches();
       delete factories;
       factories = nullptr;
   }
}

UObject* 
ICUService::get(const UnicodeString& descriptor, UErrorCode& status) const 
{
   return get(descriptor, nullptr, status);
}

UObject* 
ICUService::get(const UnicodeString& descriptor, UnicodeString* actualReturn, UErrorCode& status) const 
{
   UObject* result = nullptr;
   ICUServiceKey* key = createKey(&descriptor, status);
   if (key) {
       result = getKey(*key, actualReturn, status);
       delete key;
   }
   return result;
}

UObject* 
ICUService::getKey(ICUServiceKey& key, UErrorCode& status) const 
{
   return getKey(key, nullptr, status);
}

// this is a vector that subclasses of ICUService can override to further customize the result object
// before returning it.  All other public get functions should call this one.

UObject* 
ICUService::getKey(ICUServiceKey& key, UnicodeString* actualReturn, UErrorCode& status) const 
{
   return getKey(key, actualReturn, nullptr, status);
}

// make it possible to call reentrantly on systems that don't have reentrant mutexes.
// we can use this simple approach since we know the situation where we're calling
// reentrantly even without knowing the thread.
class XMutex : public UMemory {
public:
   inline XMutex(UMutex *mutex, UBool reentering) 
       : fMutex(mutex)
       , fActive(!reentering) 
   {
       if (fActive) umtx_lock(fMutex);
   }
   inline ~XMutex() {
       if (fActive) umtx_unlock(fMutex);
   }

private:
   UMutex  *fMutex;
   UBool fActive;
};

// called only by factories, treat as private
UObject* 
ICUService::getKey(ICUServiceKey& key, UnicodeString* actualReturn, const ICUServiceFactory* factory, UErrorCode& status) const 
{
   if (U_FAILURE(status)) {
       return nullptr;
   }

   if (isDefault()) {
       return handleDefault(key, actualReturn, status);
   }

   ICUService* ncthis = const_cast<ICUService*>(this); // cast away semantic const

   CacheEntry* result = nullptr;
   {
       // The factory list can't be modified until we're done, 
       // otherwise we might update the cache with an invalid result.
       // The cache has to stay in synch with the factory list.
       // ICU doesn't have monitors so we can't use rw locks, so 
       // we single-thread everything using this service, for now.

       // if factory is not null, we're calling from within the mutex,
       // and since some unix machines don't have reentrant mutexes we
       // need to make sure not to try to lock it again.
       XMutex mutex(&lock, factory != nullptr);

       if (serviceCache == nullptr) {
           ncthis->serviceCache = new Hashtable(status);
           if (ncthis->serviceCache == nullptr) {
               status = U_MEMORY_ALLOCATION_ERROR;
               return nullptr;
           }
           if (U_FAILURE(status)) {
               delete serviceCache;
               return nullptr;
           }
           serviceCache->setValueDeleter(cacheDeleter);
       }

       UnicodeString currentDescriptor;
       LocalPointer<UVector> cacheDescriptorList;
       UBool putInCache = false;

       int32_t startIndex = 0;
       int32_t limit = factories->size();
       UBool cacheResult = true;

       if (factory != nullptr) {
           for (int32_t i = 0; i < limit; ++i) {
               if (factory == static_cast<const ICUServiceFactory*>(factories->elementAt(i))) {
                   startIndex = i + 1;
                   break;
               }
           }
           if (startIndex == 0) {
               // throw new InternalError("Factory " + factory + "not registered with service: " + this);
               status = U_ILLEGAL_ARGUMENT_ERROR;
               return nullptr;
           }
           cacheResult = false;
       }

       do {
           currentDescriptor.remove();
           key.currentDescriptor(currentDescriptor);
           result = static_cast<CacheEntry*>(serviceCache->get(currentDescriptor));
           if (result != nullptr) {
               break;
           }

           // first test of cache failed, so we'll have to update
           // the cache if we eventually succeed-- that is, if we're 
           // going to update the cache at all.
           putInCache = true;

           int32_t index = startIndex;
           while (index < limit) {
               ICUServiceFactory* f = static_cast<ICUServiceFactory*>(factories->elementAt(index++));
               LocalPointer<UObject> service(f->create(key, this, status));
               if (U_FAILURE(status)) {
                   return nullptr;
               }
               if (service.isValid()) {
                   result = new CacheEntry(currentDescriptor, service.getAlias());
                   if (result == nullptr) {
                       status = U_MEMORY_ALLOCATION_ERROR;
                       return nullptr;
                   }
                   service.orphan(); // result now owns service.

                   goto outerEnd;
               }
           }

           // prepare to load the cache with all additional ids that 
           // will resolve to result, assuming we'll succeed.  We
           // don't want to keep querying on an id that's going to
           // fallback to the one that succeeded, we want to hit the
           // cache the first time next goaround.
           if (cacheDescriptorList.isNull()) {
               cacheDescriptorList.adoptInsteadAndCheckErrorCode(new UVector(uprv_deleteUObject, nullptr, 5, status), status);
               if (U_FAILURE(status)) {
                   return nullptr;
               }
           }

           LocalPointer<UnicodeString> idToCache(new UnicodeString(currentDescriptor), status);
           if (U_FAILURE(status)) {
               return nullptr;
           }
           if (idToCache->isBogus()) {
               status = U_MEMORY_ALLOCATION_ERROR;
               return nullptr;
           }
           cacheDescriptorList->adoptElement(idToCache.orphan(), status);
           if (U_FAILURE(status)) {
               return nullptr;
           }
       } while (key.fallback());
outerEnd:

       if (result != nullptr) {
           if (putInCache && cacheResult) {
               serviceCache->put(result->actualDescriptor, result, status);
               if (U_FAILURE(status)) {
                   return nullptr;
               }

               if (cacheDescriptorList.isValid()) {
                   for (int32_t i = cacheDescriptorList->size(); --i >= 0;) {
                       UnicodeString* desc = static_cast<UnicodeString*>(cacheDescriptorList->elementAt(i));

                       serviceCache->put(*desc, result, status);
                       if (U_FAILURE(status)) {
                           return nullptr;
                       }

                       result->ref();
                       cacheDescriptorList->removeElementAt(i);
                   }
               }
           }

           if (actualReturn != nullptr) {
               // strip null prefix
               if (result->actualDescriptor.indexOf(static_cast<char16_t>(0x2f)) == 0) { // U+002f=slash (/)
                   actualReturn->remove();
                   actualReturn->append(result->actualDescriptor, 
                       1, 
                       result->actualDescriptor.length() - 1);
               } else {
                   *actualReturn = result->actualDescriptor;
               }

               if (actualReturn->isBogus()) {
                   status = U_MEMORY_ALLOCATION_ERROR;
                   delete result;
                   return nullptr;
               }
           }

           UObject* service = cloneInstance(result->service);
           if (putInCache && !cacheResult) {
               delete result;
           }
           return service;
       }
   }

   return handleDefault(key, actualReturn, status);
}

UObject* 
ICUService::handleDefault(const ICUServiceKey& /* key */, UnicodeString* /* actualIDReturn */, UErrorCode& /* status */) const 
{
   return nullptr;
}

UVector& 
ICUService::getVisibleIDs(UVector& result, UErrorCode& status) const {
   return getVisibleIDs(result, nullptr, status);
}

UVector& 
ICUService::getVisibleIDs(UVector& result, const UnicodeString* matchID, UErrorCode& status) const 
{
   result.removeAllElements();

   if (U_FAILURE(status)) {
       return result;
   }
   UObjectDeleter *savedDeleter = result.setDeleter(uprv_deleteUObject);

   {
       Mutex mutex(&lock);
       const Hashtable* map = getVisibleIDMap(status);
       if (map != nullptr) {
           ICUServiceKey* fallbackKey = createKey(matchID, status);

           for (int32_t pos = UHASH_FIRST; U_SUCCESS(status); ) {
               const UHashElement* e = map->nextElement(pos);
               if (e == nullptr) {
                   break;
               }

               const UnicodeString* id = static_cast<const UnicodeString*>(e->key.pointer);
               if (fallbackKey != nullptr) {
                   if (!fallbackKey->isFallbackOf(*id)) {
                       continue;
                   }
               }

               LocalPointer<UnicodeString> idClone(id->clone(), status);
               result.adoptElement(idClone.orphan(), status);
           }
           delete fallbackKey;
       }
   }
   if (U_FAILURE(status)) {
       result.removeAllElements();
   }
   result.setDeleter(savedDeleter);
   return result;
}

const Hashtable* 
ICUService::getVisibleIDMap(UErrorCode& status) const {
   if (U_FAILURE(status)) return nullptr;

   // must only be called when lock is already held

   ICUService* ncthis = const_cast<ICUService*>(this); // cast away semantic const
   if (idCache == nullptr) {
       ncthis->idCache = new Hashtable(status);
       if (idCache == nullptr) {
           status = U_MEMORY_ALLOCATION_ERROR;
       } else if (factories != nullptr) {
           for (int32_t pos = factories->size(); --pos >= 0;) {
               ICUServiceFactory* f = static_cast<ICUServiceFactory*>(factories->elementAt(pos));
               f->updateVisibleIDs(*idCache, status);
           }
           if (U_FAILURE(status)) {
               delete idCache;
               ncthis->idCache = nullptr;
           }
       }
   }

   return idCache;
}


UnicodeString& 
ICUService::getDisplayName(const UnicodeString& id, UnicodeString& result) const 
{
   return getDisplayName(id, result, Locale::getDefault());
}

UnicodeString& 
ICUService::getDisplayName(const UnicodeString& id, UnicodeString& result, const Locale& locale) const 
{
   {
       UErrorCode status = U_ZERO_ERROR;
       Mutex mutex(&lock);
       const Hashtable* map = getVisibleIDMap(status);
       if (map != nullptr) {
           ICUServiceFactory* f = static_cast<ICUServiceFactory*>(map->get(id));
           if (f != nullptr) {
               f->getDisplayName(id, locale, result);
               return result;
           }

           // fallback
           status = U_ZERO_ERROR;
           ICUServiceKey* fallbackKey = createKey(&id, status);
           while (fallbackKey != nullptr && fallbackKey->fallback()) {
               UnicodeString us;
               fallbackKey->currentID(us);
               f = static_cast<ICUServiceFactory*>(map->get(us));
               if (f != nullptr) {
                   f->getDisplayName(id, locale, result);
                   delete fallbackKey;
                   return result;
               }
           }
           delete fallbackKey;
       }
   }
   result.setToBogus();
   return result;
}

UVector& 
ICUService::getDisplayNames(UVector& result, UErrorCode& status) const 
{
   return getDisplayNames(result, Locale::getDefault(), nullptr, status);
}


UVector& 
ICUService::getDisplayNames(UVector& result, const Locale& locale, UErrorCode& status) const 
{
   return getDisplayNames(result, locale, nullptr, status);
}

UVector& 
ICUService::getDisplayNames(UVector& result, 
                           const Locale& locale, 
                           const UnicodeString* matchID, 
                           UErrorCode& status) const 
{
   result.removeAllElements();
   result.setDeleter(userv_deleteStringPair);
   if (U_SUCCESS(status)) {
       ICUService* ncthis = const_cast<ICUService*>(this); // cast away semantic const
       Mutex mutex(&lock);

       if (dnCache != nullptr && dnCache->locale != locale) {
           delete dnCache;
           ncthis->dnCache = nullptr;
       }

       if (dnCache == nullptr) {
           const Hashtable* m = getVisibleIDMap(status);
           if (U_FAILURE(status)) {
               return result;
           }
           ncthis->dnCache = new DNCache(locale); 
           if (dnCache == nullptr) {
               status = U_MEMORY_ALLOCATION_ERROR;
               return result;
           }

           int32_t pos = UHASH_FIRST;
           const UHashElement* entry = nullptr;
           while ((entry = m->nextElement(pos)) != nullptr) {
               const UnicodeString* id = static_cast<const UnicodeString*>(entry->key.pointer);
               ICUServiceFactory* f = static_cast<ICUServiceFactory*>(entry->value.pointer);
               UnicodeString dname;
               f->getDisplayName(*id, locale, dname);
               if (dname.isBogus()) {
                   status = U_MEMORY_ALLOCATION_ERROR;
               } else {
                   dnCache->cache.put(dname, (void*)id, status); // share pointer with visibleIDMap
                   if (U_SUCCESS(status)) {
                       continue;
                   }
               }
               delete dnCache;
               ncthis->dnCache = nullptr;
               return result;
           }
       }
   }

   ICUServiceKey* matchKey = createKey(matchID, status);
   /* To ensure that all elements in the hashtable are iterated, set pos to -1.
    * nextElement(pos) will skip the position at pos and begin the iteration
    * at the next position, which in this case will be 0.
    */
   int32_t pos = UHASH_FIRST; 
   const UHashElement *entry = nullptr;
   while ((entry = dnCache->cache.nextElement(pos)) != nullptr) {
       const UnicodeString* id = static_cast<const UnicodeString*>(entry->value.pointer);
       if (matchKey != nullptr && !matchKey->isFallbackOf(*id)) {
           continue;
       }
       const UnicodeString* dn = static_cast<const UnicodeString*>(entry->key.pointer);
       StringPair* sp = StringPair::create(*id, *dn, status);
       result.adoptElement(sp, status);
       if (U_FAILURE(status)) {
           result.removeAllElements();
           break;
       }
   }
   delete matchKey;

   return result;
}

URegistryKey
ICUService::registerInstance(UObject* objToAdopt, const UnicodeString& id, UErrorCode& status) 
{
   return registerInstance(objToAdopt, id, true, status);
}

URegistryKey
ICUService::registerInstance(UObject* objToAdopt, const UnicodeString& id, UBool visible, UErrorCode& status) 
{
   ICUServiceKey* key = createKey(&id, status);
   if (key != nullptr) {
       UnicodeString canonicalID;
       key->canonicalID(canonicalID);
       delete key;

       ICUServiceFactory* f = createSimpleFactory(objToAdopt, canonicalID, visible, status);
       if (f != nullptr) {
           return registerFactory(f, status);
       }
   }
   delete objToAdopt;
   return nullptr;
}

ICUServiceFactory* 
ICUService::createSimpleFactory(UObject* objToAdopt, const UnicodeString& id, UBool visible, UErrorCode& status)
{
   if (U_SUCCESS(status)) {
       if ((objToAdopt != nullptr) && (!id.isBogus())) {
           return new SimpleFactory(objToAdopt, id, visible);
       }
       status = U_ILLEGAL_ARGUMENT_ERROR;
   }
   return nullptr;
}

URegistryKey
ICUService::registerFactory(ICUServiceFactory* factoryToAdopt, UErrorCode& status)
{
   LocalPointer<ICUServiceFactory>lpFactoryToAdopt(factoryToAdopt);
   if (U_FAILURE(status) || factoryToAdopt == nullptr) {
       return nullptr;
   }
   {
       Mutex mutex(&lock);

       if (factories == nullptr) {
           LocalPointer<UVector> lpFactories(new UVector(uprv_deleteUObject, nullptr, status), status);
           if (U_FAILURE(status)) {
               return nullptr;
           }
           factories = lpFactories.orphan();
       }
       factories->insertElementAt(lpFactoryToAdopt.orphan(), 0, status);
       if (U_SUCCESS(status)) {
           clearCaches();
       }
   }   // Close of mutex lock block.

   if (U_SUCCESS(status)) {
       notifyChanged();
       return (URegistryKey)factoryToAdopt;
   } else {
       return nullptr;
   }
}

UBool 
ICUService::unregister(URegistryKey rkey, UErrorCode& status) 
{
   ICUServiceFactory *factory = (ICUServiceFactory*)rkey;
   UBool result = false;
   if (factory != nullptr && factories != nullptr) {
       Mutex mutex(&lock);

       if (factories->removeElement(factory)) {
           clearCaches();
           result = true;
       } else {
           status = U_ILLEGAL_ARGUMENT_ERROR;
           delete factory;
       }
   }
   if (result) {
       notifyChanged();
   }
   return result;
}

void 
ICUService::reset() 
{
   {
       Mutex mutex(&lock);
       reInitializeFactories();
       clearCaches();
   }
   notifyChanged();
}

void 
ICUService::reInitializeFactories() 
{
   if (factories != nullptr) {
       factories->removeAllElements();
   }
}

UBool 
ICUService::isDefault() const 
{
   return countFactories() == 0;
}

ICUServiceKey* 
ICUService::createKey(const UnicodeString* id, UErrorCode& status) const 
{
   return (U_FAILURE(status) || id == nullptr) ? nullptr : new ICUServiceKey(*id);
}

void 
ICUService::clearCaches() 
{
   // callers synchronize before use
   ++timestamp;
   delete dnCache;
   dnCache = nullptr;
   delete idCache;
   idCache = nullptr;
   delete serviceCache; serviceCache = nullptr;
}

void 
ICUService::clearServiceCache() 
{
   // callers synchronize before use
   delete serviceCache; serviceCache = nullptr;
}

UBool 
ICUService::acceptsListener(const EventListener& l) const 
{
   return dynamic_cast<const ServiceListener*>(&l) != nullptr;
}

void 
ICUService::notifyListener(EventListener& l) const 
{
   (static_cast<ServiceListener&>(l)).serviceChanged(*this);
}

UnicodeString&
ICUService::getName(UnicodeString& result) const 
{
   return result.append(name);
}

int32_t 
ICUService::countFactories() const 
{
   return factories == nullptr ? 0 : factories->size();
}

int32_t
ICUService::getTimestamp() const
{
   return timestamp;
}

U_NAMESPACE_END

/* UCONFIG_NO_SERVICE */
#endif