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

1 files changed, 291 insertions, 291 deletions

diff --git a/contrib/libs/icu/common/pluralmap.h b/contrib/libs/icu/common/pluralmap.h
index 1a0a56325b..db644093a1 100644
--- a/contrib/libs/icu/common/pluralmap.h
+++ b/contrib/libs/icu/common/pluralmap.h
@@ -1,292 +1,292 @@
 // © 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 pluralmap.h - PluralMap class that maps plural categories to values. 
-****************************************************************************** 
-*/ 
- 
-#ifndef __PLURAL_MAP_H__ 
-#define __PLURAL_MAP_H__ 
- 
-#include "unicode/uobject.h" 
-#include "cmemory.h" 
- 
-U_NAMESPACE_BEGIN 
- 
-class UnicodeString; 
- 
-class U_COMMON_API PluralMapBase : public UMemory { 
-public: 
-    /** 
-     * The names of all the plural categories. NONE is not an actual plural 
-     * category, but rather represents the absense of a plural category. 
-     */ 
-    enum Category { 
-        NONE = -1, 
-        OTHER, 
-        ZERO, 
-        ONE, 
-        TWO, 
-        FEW, 
-        MANY, 
-        CATEGORY_COUNT 
-    }; 
- 
-    /** 
-     * Converts a category name such as "zero", "one", "two", "few", "many" 
-     * or "other" to a category enum. Returns NONE for an unrecognized 
-     * category name. 
-     */ 
-    static Category toCategory(const char *categoryName); 
- 
-    /** 
-     * Converts a category name such as "zero", "one", "two", "few", "many" 
-     * or "other" to a category enum.  Returns NONE for urecongized 
-     * category name. 
-     */ 
-    static Category toCategory(const UnicodeString &categoryName); 
- 
-    /** 
-     * Converts a category to a name. 
-     * Passing NONE or CATEGORY_COUNT for category returns NULL. 
-     */ 
-    static const char *getCategoryName(Category category); 
-}; 
- 
-/** 
- * A Map of plural categories to values. It maintains ownership of the 
- * values. 
- * 
- * Type T is the value type. T must provide the followng: 
- * 1) Default constructor 
- * 2) Copy constructor 
- * 3) Assignment operator 
- * 4) Must extend UMemory 
- */ 
-template<typename T> 
-class PluralMap : public PluralMapBase { 
-public: 
-    /** 
-     * Other category is maps to a copy of the default value. 
-     */ 
-    PluralMap() : fOtherVariant() { 
-        initializeNew(); 
-    } 
- 
-    /** 
-     * Other category is mapped to otherVariant. 
-     */ 
-    PluralMap(const T &otherVariant) : fOtherVariant(otherVariant) { 
-        initializeNew(); 
-    } 
- 
-    PluralMap(const PluralMap<T> &other) : fOtherVariant(other.fOtherVariant) { 
-        fVariants[0] = &fOtherVariant; 
-        for (int32_t i = 1; i < UPRV_LENGTHOF(fVariants); ++i) { 
-            fVariants[i] = other.fVariants[i] ? 
-                    new T(*other.fVariants[i]) : NULL; 
-        } 
-    } 
- 
-    PluralMap<T> &operator=(const PluralMap<T> &other) { 
-        if (this == &other) { 
-            return *this; 
-        } 
-        for (int32_t i = 0; i < UPRV_LENGTHOF(fVariants); ++i) { 
-            if (fVariants[i] != NULL && other.fVariants[i] != NULL) { 
-                *fVariants[i] = *other.fVariants[i]; 
-            } else if (fVariants[i] != NULL) { 
-                delete fVariants[i]; 
-                fVariants[i] = NULL; 
-            } else if (other.fVariants[i] != NULL) { 
-                fVariants[i] = new T(*other.fVariants[i]); 
-            } else { 
-                // do nothing 
-            } 
-        } 
-        return *this; 
-    } 
- 
-    ~PluralMap() { 
-        for (int32_t i = 1; i < UPRV_LENGTHOF(fVariants); ++i) { 
-            delete fVariants[i]; 
-        } 
-    } 
- 
-    /** 
-     * Removes all mappings and makes 'other' point to the default value. 
-     */ 
-    void clear() { 
-        *fVariants[0] = T(); 
-        for (int32_t i = 1; i < UPRV_LENGTHOF(fVariants); ++i) { 
-            delete fVariants[i]; 
-            fVariants[i] = NULL; 
-        } 
-    } 
- 
-    /** 
-     * Iterates through the mappings in this instance, set index to NONE 
-     * prior to using. Call next repeatedly to get the values until it 
-     * returns NULL. Each time next returns, caller may pass index 
-     * to getCategoryName() to get the name of the plural category. 
-     * When this function returns NULL, index is CATEGORY_COUNT 
-     */ 
-    const T *next(Category &index) const { 
-        int32_t idx = index; 
-        ++idx; 
-        for (; idx < UPRV_LENGTHOF(fVariants); ++idx) { 
-            if (fVariants[idx] != NULL) { 
-                index = static_cast<Category>(idx); 
-                return fVariants[idx]; 
-            } 
-        } 
-        index = static_cast<Category>(idx); 
-        return NULL; 
-    } 
- 
-    /** 
-     * non const version of next. 
-     */ 
-    T *nextMutable(Category &index) { 
-        const T *result = next(index); 
-        return const_cast<T *>(result); 
-    } 
- 
-    /** 
-     * Returns the 'other' variant. 
-     * Same as calling get(OTHER). 
-     */ 
-    const T &getOther() const { 
-        return get(OTHER); 
-    } 
- 
-    /** 
-     * Returns the value associated with a category. 
-     * If no value found, or v is NONE or CATEGORY_COUNT, falls 
-     * back to returning the value for the 'other' category. 
-     */ 
-    const T &get(Category v) const { 
-        int32_t index = v; 
-        if (index < 0 || index >= UPRV_LENGTHOF(fVariants) || fVariants[index] == NULL) { 
-            return *fVariants[0]; 
-        } 
-        return *fVariants[index]; 
-    } 
- 
-    /** 
-     * Convenience routine to get the value by category name. Otherwise 
-     * works just like get(Category). 
-     */ 
-    const T &get(const char *category) const { 
-        return get(toCategory(category)); 
-    } 
- 
-    /** 
-     * Convenience routine to get the value by category name as a 
-     * UnicodeString. Otherwise works just like get(category). 
-     */ 
-    const T &get(const UnicodeString &category) const { 
-        return get(toCategory(category)); 
-    } 
- 
-    /** 
-     * Returns a pointer to the value associated with a category 
-     * that caller can safely modify. If the value was defaulting to the 'other' 
-     * variant because no explicit value was stored, this method creates a 
-     * new value using the default constructor at the returned pointer. 
-     * 
-     * @param category the category with the value to change. 
-     * @param status error returned here if index is NONE or CATEGORY_COUNT 
-     *  or memory could not be allocated, or any other error happens. 
-     */ 
-    T *getMutable( 
-            Category category, 
-            UErrorCode &status) { 
-        return getMutable(category, NULL, status); 
-    } 
- 
-    /** 
-     * Convenience routine to get a mutable pointer to a value by category name. 
-     * Otherwise works just like getMutable(Category, UErrorCode &). 
-     * reports an error if the category name is invalid. 
-     */ 
-    T *getMutable( 
-            const char *category, 
-            UErrorCode &status) { 
-        return getMutable(toCategory(category), NULL, status); 
-    } 
- 
-    /** 
-     * Just like getMutable(Category, UErrorCode &) but copies defaultValue to 
-     * returned pointer if it was defaulting to the 'other' variant 
-     * because no explicit value was stored. 
-     */ 
-    T *getMutableWithDefault( 
-            Category category, 
-            const T &defaultValue, 
-            UErrorCode &status) { 
-        return getMutable(category, &defaultValue, status); 
-    } 
- 
-    /** 
-     * Returns TRUE if this object equals rhs. 
-     */ 
-    UBool equals( 
-            const PluralMap<T> &rhs, 
-            UBool (*eqFunc)(const T &, const T &)) const { 
-        for (int32_t i = 0; i < UPRV_LENGTHOF(fVariants); ++i) { 
-            if (fVariants[i] == rhs.fVariants[i]) { 
-                continue; 
-            } 
-            if (fVariants[i] == NULL || rhs.fVariants[i] == NULL) { 
-                return FALSE; 
-            } 
-            if (!eqFunc(*fVariants[i], *rhs.fVariants[i])) { 
-                return FALSE; 
-            } 
-        } 
-        return TRUE; 
-    } 
- 
-private: 
-    T fOtherVariant; 
-    T* fVariants[6]; 
- 
-    T *getMutable( 
-            Category category, 
-            const T *defaultValue, 
-            UErrorCode &status) { 
-        if (U_FAILURE(status)) { 
-            return NULL; 
-        } 
-        int32_t index = category; 
-        if (index < 0 || index >= UPRV_LENGTHOF(fVariants)) { 
-            status = U_ILLEGAL_ARGUMENT_ERROR; 
-            return NULL; 
-        } 
-        if (fVariants[index] == NULL) { 
-            fVariants[index] = defaultValue == NULL ? 
-                    new T() : new T(*defaultValue); 
-        } 
-        if (!fVariants[index]) { 
-            status = U_MEMORY_ALLOCATION_ERROR; 
-        } 
-        return fVariants[index]; 
-    } 
- 
-    void initializeNew() { 
-        fVariants[0] = &fOtherVariant; 
-        for (int32_t i = 1; i < UPRV_LENGTHOF(fVariants); ++i) { 
-            fVariants[i] = NULL; 
-        } 
-    } 
-}; 
- 
-U_NAMESPACE_END 
- 
-#endif 
+// License & terms of use: http://www.unicode.org/copyright.html
+/*
+******************************************************************************
+* Copyright (C) 2015, International Business Machines Corporation and
+* others. All Rights Reserved.
+******************************************************************************
+*
+* File pluralmap.h - PluralMap class that maps plural categories to values.
+******************************************************************************
+*/
+
+#ifndef __PLURAL_MAP_H__
+#define __PLURAL_MAP_H__
+
+#include "unicode/uobject.h"
+#include "cmemory.h"
+
+U_NAMESPACE_BEGIN
+
+class UnicodeString;
+
+class U_COMMON_API PluralMapBase : public UMemory {
+public:
+    /**
+     * The names of all the plural categories. NONE is not an actual plural
+     * category, but rather represents the absense of a plural category.
+     */
+    enum Category {
+        NONE = -1,
+        OTHER,
+        ZERO,
+        ONE,
+        TWO,
+        FEW,
+        MANY,
+        CATEGORY_COUNT
+    };
+
+    /**
+     * Converts a category name such as "zero", "one", "two", "few", "many"
+     * or "other" to a category enum. Returns NONE for an unrecognized
+     * category name.
+     */
+    static Category toCategory(const char *categoryName);
+
+    /**
+     * Converts a category name such as "zero", "one", "two", "few", "many"
+     * or "other" to a category enum.  Returns NONE for urecongized
+     * category name.
+     */
+    static Category toCategory(const UnicodeString &categoryName);
+
+    /**
+     * Converts a category to a name.
+     * Passing NONE or CATEGORY_COUNT for category returns NULL.
+     */
+    static const char *getCategoryName(Category category);
+};
+
+/**
+ * A Map of plural categories to values. It maintains ownership of the
+ * values.
+ *
+ * Type T is the value type. T must provide the followng:
+ * 1) Default constructor
+ * 2) Copy constructor
+ * 3) Assignment operator
+ * 4) Must extend UMemory
+ */
+template<typename T>
+class PluralMap : public PluralMapBase {
+public:
+    /**
+     * Other category is maps to a copy of the default value.
+     */
+    PluralMap() : fOtherVariant() {
+        initializeNew();
+    }
+
+    /**
+     * Other category is mapped to otherVariant.
+     */
+    PluralMap(const T &otherVariant) : fOtherVariant(otherVariant) {
+        initializeNew();
+    }
+
+    PluralMap(const PluralMap<T> &other) : fOtherVariant(other.fOtherVariant) {
+        fVariants[0] = &fOtherVariant;
+        for (int32_t i = 1; i < UPRV_LENGTHOF(fVariants); ++i) {
+            fVariants[i] = other.fVariants[i] ?
+                    new T(*other.fVariants[i]) : NULL;
+        }
+    }
+
+    PluralMap<T> &operator=(const PluralMap<T> &other) {
+        if (this == &other) {
+            return *this;
+        }
+        for (int32_t i = 0; i < UPRV_LENGTHOF(fVariants); ++i) {
+            if (fVariants[i] != NULL && other.fVariants[i] != NULL) {
+                *fVariants[i] = *other.fVariants[i];
+            } else if (fVariants[i] != NULL) {
+                delete fVariants[i];
+                fVariants[i] = NULL;
+            } else if (other.fVariants[i] != NULL) {
+                fVariants[i] = new T(*other.fVariants[i]);
+            } else {
+                // do nothing
+            }
+        }
+        return *this;
+    }
+
+    ~PluralMap() {
+        for (int32_t i = 1; i < UPRV_LENGTHOF(fVariants); ++i) {
+            delete fVariants[i];
+        }
+    }
+
+    /**
+     * Removes all mappings and makes 'other' point to the default value.
+     */
+    void clear() {
+        *fVariants[0] = T();
+        for (int32_t i = 1; i < UPRV_LENGTHOF(fVariants); ++i) {
+            delete fVariants[i];
+            fVariants[i] = NULL;
+        }
+    }
+
+    /**
+     * Iterates through the mappings in this instance, set index to NONE
+     * prior to using. Call next repeatedly to get the values until it
+     * returns NULL. Each time next returns, caller may pass index
+     * to getCategoryName() to get the name of the plural category.
+     * When this function returns NULL, index is CATEGORY_COUNT
+     */
+    const T *next(Category &index) const {
+        int32_t idx = index;
+        ++idx;
+        for (; idx < UPRV_LENGTHOF(fVariants); ++idx) {
+            if (fVariants[idx] != NULL) {
+                index = static_cast<Category>(idx);
+                return fVariants[idx];
+            }
+        }
+        index = static_cast<Category>(idx);
+        return NULL;
+    }
+
+    /**
+     * non const version of next.
+     */
+    T *nextMutable(Category &index) {
+        const T *result = next(index);
+        return const_cast<T *>(result);
+    }
+
+    /**
+     * Returns the 'other' variant.
+     * Same as calling get(OTHER).
+     */
+    const T &getOther() const {
+        return get(OTHER);
+    }
+
+    /**
+     * Returns the value associated with a category.
+     * If no value found, or v is NONE or CATEGORY_COUNT, falls
+     * back to returning the value for the 'other' category.
+     */
+    const T &get(Category v) const {
+        int32_t index = v;
+        if (index < 0 || index >= UPRV_LENGTHOF(fVariants) || fVariants[index] == NULL) {
+            return *fVariants[0];
+        }
+        return *fVariants[index];
+    }
+
+    /**
+     * Convenience routine to get the value by category name. Otherwise
+     * works just like get(Category).
+     */
+    const T &get(const char *category) const {
+        return get(toCategory(category));
+    }
+
+    /**
+     * Convenience routine to get the value by category name as a
+     * UnicodeString. Otherwise works just like get(category).
+     */
+    const T &get(const UnicodeString &category) const {
+        return get(toCategory(category));
+    }
+
+    /**
+     * Returns a pointer to the value associated with a category
+     * that caller can safely modify. If the value was defaulting to the 'other'
+     * variant because no explicit value was stored, this method creates a
+     * new value using the default constructor at the returned pointer.
+     *
+     * @param category the category with the value to change.
+     * @param status error returned here if index is NONE or CATEGORY_COUNT
+     *  or memory could not be allocated, or any other error happens.
+     */
+    T *getMutable(
+            Category category,
+            UErrorCode &status) {
+        return getMutable(category, NULL, status);
+    }
+
+    /**
+     * Convenience routine to get a mutable pointer to a value by category name.
+     * Otherwise works just like getMutable(Category, UErrorCode &).
+     * reports an error if the category name is invalid.
+     */
+    T *getMutable(
+            const char *category,
+            UErrorCode &status) {
+        return getMutable(toCategory(category), NULL, status);
+    }
+
+    /**
+     * Just like getMutable(Category, UErrorCode &) but copies defaultValue to
+     * returned pointer if it was defaulting to the 'other' variant
+     * because no explicit value was stored.
+     */
+    T *getMutableWithDefault(
+            Category category,
+            const T &defaultValue,
+            UErrorCode &status) {
+        return getMutable(category, &defaultValue, status);
+    }
+
+    /**
+     * Returns TRUE if this object equals rhs.
+     */
+    UBool equals(
+            const PluralMap<T> &rhs,
+            UBool (*eqFunc)(const T &, const T &)) const {
+        for (int32_t i = 0; i < UPRV_LENGTHOF(fVariants); ++i) {
+            if (fVariants[i] == rhs.fVariants[i]) {
+                continue;
+            }
+            if (fVariants[i] == NULL || rhs.fVariants[i] == NULL) {
+                return FALSE;
+            }
+            if (!eqFunc(*fVariants[i], *rhs.fVariants[i])) {
+                return FALSE;
+            }
+        }
+        return TRUE;
+    }
+
+private:
+    T fOtherVariant;
+    T* fVariants[6];
+
+    T *getMutable(
+            Category category,
+            const T *defaultValue,
+            UErrorCode &status) {
+        if (U_FAILURE(status)) {
+            return NULL;
+        }
+        int32_t index = category;
+        if (index < 0 || index >= UPRV_LENGTHOF(fVariants)) {
+            status = U_ILLEGAL_ARGUMENT_ERROR;
+            return NULL;
+        }
+        if (fVariants[index] == NULL) {
+            fVariants[index] = defaultValue == NULL ?
+                    new T() : new T(*defaultValue);
+        }
+        if (!fVariants[index]) {
+            status = U_MEMORY_ALLOCATION_ERROR;
+        }
+        return fVariants[index];
+    }
+
+    void initializeNew() {
+        fVariants[0] = &fOtherVariant;
+        for (int32_t i = 1; i < UPRV_LENGTHOF(fVariants); ++i) {
+            fVariants[i] = NULL;
+        }
+    }
+};
+
+U_NAMESPACE_END
+
+#endif