Restoring authorship annotation for <neksard@yandex-team.ru>. Commit 2 of 2.

1 files changed, 151 insertions, 151 deletions

diff --git a/contrib/libs/icu/common/sharedobject.h b/contrib/libs/icu/common/sharedobject.h
index a9b77ea6b5..c0a5aba478 100644
--- a/contrib/libs/icu/common/sharedobject.h
+++ b/contrib/libs/icu/common/sharedobject.h
@@ -1,184 +1,184 @@
 // © 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 
- 
+// 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() { } 
- 
-    /** 
+/**
+ * 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(); 
- 
-    /** 
+
+    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. 
-     */ 
+     * 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. 
-     */ 
+
+    /**
+     * 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: 
+     */
+    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; 
+    mutable int32_t softRefCount;
     friend class UnifiedCache;
- 
+
     /**
      * Reference count, excluding references from within the UnifiedCache implementation.
      */
-    mutable u_atomic_int32_t hardRefCount; 
+    mutable u_atomic_int32_t hardRefCount;
     
-    mutable const UnifiedCacheBase *cachePtr; 
- 
-}; 
- 
-U_NAMESPACE_END 
- 
-#endif 
+    mutable const UnifiedCacheBase *cachePtr;
+
+};
+
+U_NAMESPACE_END
+
+#endif