1 files changed, 0 insertions, 184 deletions
diff --git a/deps/node/deps/icu-small/source/common/sharedobject.h b/deps/node/deps/icu-small/source/common/sharedobject.h
deleted file mode 100644
index 878594c7..00000000
--- a/deps/node/deps/icu-small/source/common/sharedobject.h
+++ /dev/null
@@ -1,184 +0,0 @@
-// © 2016 and later: Unicode, Inc. and others.
-// License & terms of use: http://www.unicode.org/copyright.html
-/*
-******************************************************************************
-* Copyright (C) 2015-2016, International Business Machines
-* Corporation and others.  All Rights Reserved.
-******************************************************************************
-* sharedobject.h
-*/
-
-#ifndef __SHAREDOBJECT_H__
-#define __SHAREDOBJECT_H__
-
-
-#include "unicode/uobject.h"
-#include "umutex.h"
-
-U_NAMESPACE_BEGIN
-
-class SharedObject;
-
-/**
- * Base class for unified cache exposing enough methods to SharedObject
- * instances to allow their addRef() and removeRef() methods to
- * update cache metrics. No other part of ICU, except for SharedObject,
- * should directly call the methods of this base class.
- */
-class U_COMMON_API UnifiedCacheBase : public UObject {
-public:
-    UnifiedCacheBase() { }
-
-    /**
-     * Notify the cache implementation that an object was seen transitioning to
-     * zero hard references. The cache may use this to keep track the number of
-     * unreferenced SharedObjects, and to trigger evictions.
-     */
-    virtual void handleUnreferencedObject() const = 0;
-
-    virtual ~UnifiedCacheBase();
-private:
-    UnifiedCacheBase(const UnifiedCacheBase &);
-    UnifiedCacheBase &operator=(const UnifiedCacheBase &);
-};
-
-/**
- * Base class for shared, reference-counted, auto-deleted objects.
- * Subclasses can be immutable.
- * If they are mutable, then they must implement their copy constructor
- * so that copyOnWrite() works.
- *
- * Either stack-allocate, use LocalPointer, or use addRef()/removeRef().
- * Sharing requires reference-counting.
- */
-class U_COMMON_API SharedObject : public UObject {
-public:
-    /** Initializes totalRefCount, softRefCount to 0. */
-    SharedObject() :
-            softRefCount(0),
-            hardRefCount(0),
-            cachePtr(NULL) {}
-
-    /** Initializes totalRefCount, softRefCount to 0. */
-    SharedObject(const SharedObject &other) :
-            UObject(other),
-            softRefCount(0),
-            hardRefCount(0),
-            cachePtr(NULL) {}
-
-    virtual ~SharedObject();
-
-    /**
-     * Increments the number of hard references to this object. Thread-safe.
-     * Not for use from within the Unified Cache implementation.
-     */
-    void addRef() const;
-
-    /**
-     * Decrements the number of hard references to this object, and
-     * arrange for possible cache-eviction and/or deletion if ref
-     * count goes to zero. Thread-safe.
-     *
-     * Not for use from within the UnifiedCache implementation.
-     */
-    void removeRef() const;
-
-    /**
-     * Returns the number of hard references for this object.
-     * Uses a memory barrier.
-     */
-    int32_t getRefCount() const;
-
-    /**
-     * If noHardReferences() == TRUE then this object has no hard references.
-     * Must be called only from within the internals of UnifiedCache.
-     */
-    inline UBool noHardReferences() const { return getRefCount() == 0; }
-
-    /**
-     * If hasHardReferences() == TRUE then this object has hard references.
-     * Must be called only from within the internals of UnifiedCache.
-     */
-    inline UBool hasHardReferences() const { return getRefCount() != 0; }
-
-    /**
-     * Deletes this object if it has no references.
-     * Available for non-cached SharedObjects only. Ownership of cached objects
-     * is with the UnifiedCache, which is solely responsible for eviction and deletion.
-     */
-    void deleteIfZeroRefCount() const;
-
-
-    /**
-     * Returns a writable version of ptr.
-     * If there is exactly one owner, then ptr itself is returned as a
-     *  non-const pointer.
-     * If there are multiple owners, then ptr is replaced with a
-     * copy-constructed clone,
-     * and that is returned.
-     * Returns NULL if cloning failed.
-     *
-     * T must be a subclass of SharedObject.
-     */
-    template<typename T>
-    static T *copyOnWrite(const T *&ptr) {
-        const T *p = ptr;
-        if(p->getRefCount() <= 1) { return const_cast<T *>(p); }
-        T *p2 = new T(*p);
-        if(p2 == NULL) { return NULL; }
-        p->removeRef();
-        ptr = p2;
-        p2->addRef();
-        return p2;
-    }
-
-    /**
-     * Makes dest an owner of the object pointed to by src while adjusting
-     * reference counts and deleting the previous object dest pointed to
-     * if necessary. Before this call is made, dest must either be NULL or
-     * be included in the reference count of the object it points to.
-     *
-     * T must be a subclass of SharedObject.
-     */
-    template<typename T>
-    static void copyPtr(const T *src, const T *&dest) {
-        if(src != dest) {
-            if(dest != NULL) { dest->removeRef(); }
-            dest = src;
-            if(src != NULL) { src->addRef(); }
-        }
-    }
-
-    /**
-     * Equivalent to copyPtr(NULL, dest).
-     */
-    template<typename T>
-    static void clearPtr(const T *&ptr) {
-        if (ptr != NULL) {
-            ptr->removeRef();
-            ptr = NULL;
-        }
-    }
-
-private:
-    /**
-     * The number of references from the UnifiedCache, which is
-     * the number of times that the sharedObject is stored as a hash table value.
-     * For use by UnifiedCache implementation code only.
-     * All access is synchronized by UnifiedCache's gCacheMutex
-     */
-    mutable int32_t softRefCount;
-    friend class UnifiedCache;
-
-    /**
-     * Reference count, excluding references from within the UnifiedCache implementation.
-     */
-    mutable u_atomic_int32_t hardRefCount;
-
-    mutable const UnifiedCacheBase *cachePtr;
-
-};
-
-U_NAMESPACE_END
-
-#endif