Restoring authorship annotation for <[email protected]>. Commit 2 of 2.

1 files changed, 232 insertions, 232 deletions

diff --git a/contrib/libs/icu/common/ruleiter.h b/contrib/libs/icu/common/ruleiter.h
index 2a4dbd32861..4e1be53823d 100644
--- a/contrib/libs/icu/common/ruleiter.h
+++ b/contrib/libs/icu/common/ruleiter.h
@@ -1,233 +1,233 @@
 // © 2016 and later: Unicode, Inc. and others.
-// License & terms of use: http://www.unicode.org/copyright.html 
-/* 
-********************************************************************** 
-* Copyright (c) 2003-2011, International Business Machines 
-* Corporation and others.  All Rights Reserved. 
-********************************************************************** 
-* Author: Alan Liu 
-* Created: September 24 2003 
-* Since: ICU 2.8 
-********************************************************************** 
-*/ 
-#ifndef _RULEITER_H_ 
-#define _RULEITER_H_ 
- 
-#include "unicode/uobject.h" 
- 
-U_NAMESPACE_BEGIN 
- 
-class UnicodeString; 
-class ParsePosition; 
-class SymbolTable; 
- 
-/** 
- * An iterator that returns 32-bit code points.  This class is deliberately 
- * <em>not</em> related to any of the ICU character iterator classes 
- * in order to minimize complexity. 
- * @author Alan Liu 
- * @since ICU 2.8 
- */ 
-class RuleCharacterIterator : public UMemory { 
- 
-    // TODO: Ideas for later.  (Do not implement if not needed, lest the 
-    // code coverage numbers go down due to unused methods.) 
-    // 1. Add a copy constructor, operator==() method. 
-    // 2. Rather than return DONE, throw an exception if the end 
-    // is reached -- this is an alternate usage model, probably not useful. 
- 
-private: 
-    /** 
-     * Text being iterated. 
-     */     
-    const UnicodeString& text; 
- 
-    /** 
-     * Position of iterator. 
-     */ 
-    ParsePosition& pos; 
- 
-    /** 
-     * Symbol table used to parse and dereference variables.  May be 0. 
-     */ 
-    const SymbolTable* sym; 
-     
-    /** 
-     * Current variable expansion, or 0 if none. 
-     */ 
-    const UnicodeString* buf; 
- 
-    /** 
-     * Position within buf.  Meaningless if buf == 0. 
-     */ 
-    int32_t bufPos; 
- 
-public: 
-    /** 
-     * Value returned when there are no more characters to iterate. 
-     */ 
-    enum { DONE = -1 }; 
- 
-    /** 
-     * Bitmask option to enable parsing of variable names.  If (options & 
-     * PARSE_VARIABLES) != 0, then an embedded variable will be expanded to 
-     * its value.  Variables are parsed using the SymbolTable API. 
-     */ 
-    enum { PARSE_VARIABLES = 1 }; 
- 
-    /** 
-     * Bitmask option to enable parsing of escape sequences.  If (options & 
-     * PARSE_ESCAPES) != 0, then an embedded escape sequence will be expanded 
-     * to its value.  Escapes are parsed using Utility.unescapeAt(). 
-     */ 
-    enum { PARSE_ESCAPES   = 2 }; 
- 
-    /** 
-     * Bitmask option to enable skipping of whitespace.  If (options & 
-     * SKIP_WHITESPACE) != 0, then Pattern_White_Space characters will be silently 
-     * skipped, as if they were not present in the input. 
-     */ 
-    enum { SKIP_WHITESPACE = 4 }; 
- 
-    /** 
-     * Constructs an iterator over the given text, starting at the given 
-     * position. 
-     * @param text the text to be iterated 
-     * @param sym the symbol table, or null if there is none.  If sym is null, 
-     * then variables will not be deferenced, even if the PARSE_VARIABLES 
-     * option is set. 
-     * @param pos upon input, the index of the next character to return.  If a 
-     * variable has been dereferenced, then pos will <em>not</em> increment as 
-     * characters of the variable value are iterated. 
-     */ 
-    RuleCharacterIterator(const UnicodeString& text, const SymbolTable* sym, 
-                          ParsePosition& pos); 
-     
-    /** 
-     * Returns true if this iterator has no more characters to return. 
-     */ 
-    UBool atEnd() const; 
- 
-    /** 
-     * Returns the next character using the given options, or DONE if there 
-     * are no more characters, and advance the position to the next 
-     * character. 
-     * @param options one or more of the following options, bitwise-OR-ed 
-     * together: PARSE_VARIABLES, PARSE_ESCAPES, SKIP_WHITESPACE. 
-     * @param isEscaped output parameter set to TRUE if the character 
-     * was escaped 
-     * @param ec input-output error code.  An error will only be set by 
-     * this routing if options includes PARSE_VARIABLES and an unknown 
-     * variable name is seen, or if options includes PARSE_ESCAPES and 
-     * an invalid escape sequence is seen. 
-     * @return the current 32-bit code point, or DONE 
-     */ 
-    UChar32 next(int32_t options, UBool& isEscaped, UErrorCode& ec); 
- 
-    /** 
-     * Returns true if this iterator is currently within a variable expansion. 
-     */ 
-    inline UBool inVariable() const; 
- 
-    /** 
-     * An opaque object representing the position of a RuleCharacterIterator. 
-     */ 
-    struct Pos : public UMemory { 
-    private: 
-        const UnicodeString* buf; 
-        int32_t pos; 
-        int32_t bufPos; 
-        friend class RuleCharacterIterator; 
-    }; 
- 
-    /** 
-     * Sets an object which, when later passed to setPos(), will 
-     * restore this iterator's position.  Usage idiom: 
-     * 
-     * RuleCharacterIterator iterator = ...; 
-     * RuleCharacterIterator::Pos pos; 
-     * iterator.getPos(pos); 
-     * for (;;) { 
-     *   iterator.getPos(pos); 
-     *   int c = iterator.next(...); 
-     *   ... 
-     * } 
-     * iterator.setPos(pos); 
-     * 
-     * @param p a position object to be set to this iterator's 
-     * current position. 
-     */ 
-    void getPos(Pos& p) const; 
- 
-    /** 
-     * Restores this iterator to the position it had when getPos() 
-     * set the given object. 
-     * @param p a position object previously set by getPos() 
-     */ 
-    void setPos(const Pos& p); 
- 
-    /** 
-     * Skips ahead past any ignored characters, as indicated by the given 
-     * options.  This is useful in conjunction with the lookahead() method. 
-     * 
-     * Currently, this only has an effect for SKIP_WHITESPACE. 
-     * @param options one or more of the following options, bitwise-OR-ed 
-     * together: PARSE_VARIABLES, PARSE_ESCAPES, SKIP_WHITESPACE. 
-     */ 
-    void skipIgnored(int32_t options); 
- 
-    /** 
-     * Returns a string containing the remainder of the characters to be 
-     * returned by this iterator, without any option processing.  If the 
-     * iterator is currently within a variable expansion, this will only 
-     * extend to the end of the variable expansion.  This method is provided 
-     * so that iterators may interoperate with string-based APIs.  The typical 
-     * sequence of calls is to call skipIgnored(), then call lookahead(), then 
-     * parse the string returned by lookahead(), then call jumpahead() to 
-     * resynchronize the iterator. 
-     * @param result a string to receive the characters to be returned 
-     * by future calls to next() 
-     * @param maxLookAhead The maximum to copy into the result. 
-     * @return a reference to result 
-     */ 
-    UnicodeString& lookahead(UnicodeString& result, int32_t maxLookAhead = -1) const; 
- 
-    /** 
-     * Advances the position by the given number of 16-bit code units. 
-     * This is useful in conjunction with the lookahead() method. 
-     * @param count the number of 16-bit code units to jump over 
-     */ 
-    void jumpahead(int32_t count); 
- 
-    /** 
-     * Returns a string representation of this object, consisting of the 
-     * characters being iterated, with a '|' marking the current position. 
-     * Position within an expanded variable is <em>not</em> indicated. 
-     * @param result output parameter to receive a string 
-     * representation of this object 
-     */ 
-//    UnicodeString& toString(UnicodeString& result) const; 
-     
-private: 
-    /** 
-     * Returns the current 32-bit code point without parsing escapes, parsing 
-     * variables, or skipping whitespace. 
-     * @return the current 32-bit code point 
-     */ 
-    UChar32 _current() const; 
-     
-    /** 
-     * Advances the position by the given amount. 
-     * @param count the number of 16-bit code units to advance past 
-     */ 
-    void _advance(int32_t count); 
-}; 
- 
-inline UBool RuleCharacterIterator::inVariable() const { 
-    return buf != 0; 
-} 
- 
-U_NAMESPACE_END 
- 
-#endif // _RULEITER_H_ 
-//eof 
+// License & terms of use: http://www.unicode.org/copyright.html
+/*
+**********************************************************************
+* Copyright (c) 2003-2011, International Business Machines
+* Corporation and others.  All Rights Reserved.
+**********************************************************************
+* Author: Alan Liu
+* Created: September 24 2003
+* Since: ICU 2.8
+**********************************************************************
+*/
+#ifndef _RULEITER_H_
+#define _RULEITER_H_
+
+#include "unicode/uobject.h"
+
+U_NAMESPACE_BEGIN
+
+class UnicodeString;
+class ParsePosition;
+class SymbolTable;
+
+/**
+ * An iterator that returns 32-bit code points.  This class is deliberately
+ * <em>not</em> related to any of the ICU character iterator classes
+ * in order to minimize complexity.
+ * @author Alan Liu
+ * @since ICU 2.8
+ */
+class RuleCharacterIterator : public UMemory {
+
+    // TODO: Ideas for later.  (Do not implement if not needed, lest the
+    // code coverage numbers go down due to unused methods.)
+    // 1. Add a copy constructor, operator==() method.
+    // 2. Rather than return DONE, throw an exception if the end
+    // is reached -- this is an alternate usage model, probably not useful.
+
+private:
+    /**
+     * Text being iterated.
+     */    
+    const UnicodeString& text;
+
+    /**
+     * Position of iterator.
+     */
+    ParsePosition& pos;
+
+    /**
+     * Symbol table used to parse and dereference variables.  May be 0.
+     */
+    const SymbolTable* sym;
+    
+    /**
+     * Current variable expansion, or 0 if none.
+     */
+    const UnicodeString* buf;
+
+    /**
+     * Position within buf.  Meaningless if buf == 0.
+     */
+    int32_t bufPos;
+
+public:
+    /**
+     * Value returned when there are no more characters to iterate.
+     */
+    enum { DONE = -1 };
+
+    /**
+     * Bitmask option to enable parsing of variable names.  If (options &
+     * PARSE_VARIABLES) != 0, then an embedded variable will be expanded to
+     * its value.  Variables are parsed using the SymbolTable API.
+     */
+    enum { PARSE_VARIABLES = 1 };
+
+    /**
+     * Bitmask option to enable parsing of escape sequences.  If (options &
+     * PARSE_ESCAPES) != 0, then an embedded escape sequence will be expanded
+     * to its value.  Escapes are parsed using Utility.unescapeAt().
+     */
+    enum { PARSE_ESCAPES   = 2 };
+
+    /**
+     * Bitmask option to enable skipping of whitespace.  If (options &
+     * SKIP_WHITESPACE) != 0, then Pattern_White_Space characters will be silently
+     * skipped, as if they were not present in the input.
+     */
+    enum { SKIP_WHITESPACE = 4 };
+
+    /**
+     * Constructs an iterator over the given text, starting at the given
+     * position.
+     * @param text the text to be iterated
+     * @param sym the symbol table, or null if there is none.  If sym is null,
+     * then variables will not be deferenced, even if the PARSE_VARIABLES
+     * option is set.
+     * @param pos upon input, the index of the next character to return.  If a
+     * variable has been dereferenced, then pos will <em>not</em> increment as
+     * characters of the variable value are iterated.
+     */
+    RuleCharacterIterator(const UnicodeString& text, const SymbolTable* sym,
+                          ParsePosition& pos);
+    
+    /**
+     * Returns true if this iterator has no more characters to return.
+     */
+    UBool atEnd() const;
+
+    /**
+     * Returns the next character using the given options, or DONE if there
+     * are no more characters, and advance the position to the next
+     * character.
+     * @param options one or more of the following options, bitwise-OR-ed
+     * together: PARSE_VARIABLES, PARSE_ESCAPES, SKIP_WHITESPACE.
+     * @param isEscaped output parameter set to TRUE if the character
+     * was escaped
+     * @param ec input-output error code.  An error will only be set by
+     * this routing if options includes PARSE_VARIABLES and an unknown
+     * variable name is seen, or if options includes PARSE_ESCAPES and
+     * an invalid escape sequence is seen.
+     * @return the current 32-bit code point, or DONE
+     */
+    UChar32 next(int32_t options, UBool& isEscaped, UErrorCode& ec);
+
+    /**
+     * Returns true if this iterator is currently within a variable expansion.
+     */
+    inline UBool inVariable() const;
+
+    /**
+     * An opaque object representing the position of a RuleCharacterIterator.
+     */
+    struct Pos : public UMemory {
+    private:
+        const UnicodeString* buf;
+        int32_t pos;
+        int32_t bufPos;
+        friend class RuleCharacterIterator;
+    };
+
+    /**
+     * Sets an object which, when later passed to setPos(), will
+     * restore this iterator's position.  Usage idiom:
+     *
+     * RuleCharacterIterator iterator = ...;
+     * RuleCharacterIterator::Pos pos;
+     * iterator.getPos(pos);
+     * for (;;) {
+     *   iterator.getPos(pos);
+     *   int c = iterator.next(...);
+     *   ...
+     * }
+     * iterator.setPos(pos);
+     *
+     * @param p a position object to be set to this iterator's
+     * current position.
+     */
+    void getPos(Pos& p) const;
+
+    /**
+     * Restores this iterator to the position it had when getPos()
+     * set the given object.
+     * @param p a position object previously set by getPos()
+     */
+    void setPos(const Pos& p);
+
+    /**
+     * Skips ahead past any ignored characters, as indicated by the given
+     * options.  This is useful in conjunction with the lookahead() method.
+     *
+     * Currently, this only has an effect for SKIP_WHITESPACE.
+     * @param options one or more of the following options, bitwise-OR-ed
+     * together: PARSE_VARIABLES, PARSE_ESCAPES, SKIP_WHITESPACE.
+     */
+    void skipIgnored(int32_t options);
+
+    /**
+     * Returns a string containing the remainder of the characters to be
+     * returned by this iterator, without any option processing.  If the
+     * iterator is currently within a variable expansion, this will only
+     * extend to the end of the variable expansion.  This method is provided
+     * so that iterators may interoperate with string-based APIs.  The typical
+     * sequence of calls is to call skipIgnored(), then call lookahead(), then
+     * parse the string returned by lookahead(), then call jumpahead() to
+     * resynchronize the iterator.
+     * @param result a string to receive the characters to be returned
+     * by future calls to next()
+     * @param maxLookAhead The maximum to copy into the result.
+     * @return a reference to result
+     */
+    UnicodeString& lookahead(UnicodeString& result, int32_t maxLookAhead = -1) const;
+
+    /**
+     * Advances the position by the given number of 16-bit code units.
+     * This is useful in conjunction with the lookahead() method.
+     * @param count the number of 16-bit code units to jump over
+     */
+    void jumpahead(int32_t count);
+
+    /**
+     * Returns a string representation of this object, consisting of the
+     * characters being iterated, with a '|' marking the current position.
+     * Position within an expanded variable is <em>not</em> indicated.
+     * @param result output parameter to receive a string
+     * representation of this object
+     */
+//    UnicodeString& toString(UnicodeString& result) const;
+    
+private:
+    /**
+     * Returns the current 32-bit code point without parsing escapes, parsing
+     * variables, or skipping whitespace.
+     * @return the current 32-bit code point
+     */
+    UChar32 _current() const;
+    
+    /**
+     * Advances the position by the given amount.
+     * @param count the number of 16-bit code units to advance past
+     */
+    void _advance(int32_t count);
+};
+
+inline UBool RuleCharacterIterator::inVariable() const {
+    return buf != 0;
+}
+
+U_NAMESPACE_END
+
+#endif // _RULEITER_H_
+//eof