--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/CSP2/CSP2_env/env-d9b9114564458d9d-741b3de822f2aaca6c6caa4325c4afce/include/unicode/edits.h	Tue Mar 18 17:55:14 2025 -0400
@@ -0,0 +1,531 @@
+// © 2016 and later: Unicode, Inc. and others.
+// License & terms of use: http://www.unicode.org/copyright.html
+
+// edits.h
+// created: 2016dec30 Markus W. Scherer
+
+#ifndef __EDITS_H__
+#define __EDITS_H__
+
+#include "unicode/utypes.h"
+
+#if U_SHOW_CPLUSPLUS_API
+
+#include "unicode/uobject.h"
+
+/**
+ * \file
+ * \brief C++ API: C++ class Edits for low-level string transformations on styled text.
+ */
+
+U_NAMESPACE_BEGIN
+
+class UnicodeString;
+
+/**
+ * Records lengths of string edits but not replacement text. Supports replacements, insertions, deletions
+ * in linear progression. Does not support moving/reordering of text.
+ *
+ * There are two types of edits: <em>change edits</em> and <em>no-change edits</em>. Add edits to
+ * instances of this class using {@link #addReplace(int32_t, int32_t)} (for change edits) and
+ * {@link #addUnchanged(int32_t)} (for no-change edits). Change edits are retained with full granularity,
+ * whereas adjacent no-change edits are always merged together. In no-change edits, there is a one-to-one
+ * mapping between code points in the source and destination strings.
+ *
+ * After all edits have been added, instances of this class should be considered immutable, and an
+ * {@link Edits::Iterator} can be used for queries.
+ *
+ * There are four flavors of Edits::Iterator:
+ *
+ * <ul>
+ * <li>{@link #getFineIterator()} retains full granularity of change edits.
+ * <li>{@link #getFineChangesIterator()} retains full granularity of change edits, and when calling
+ * next() on the iterator, skips over no-change edits (unchanged regions).
+ * <li>{@link #getCoarseIterator()} treats adjacent change edits as a single edit. (Adjacent no-change
+ * edits are automatically merged during the construction phase.)
+ * <li>{@link #getCoarseChangesIterator()} treats adjacent change edits as a single edit, and when
+ * calling next() on the iterator, skips over no-change edits (unchanged regions).
+ * </ul>
+ *
+ * For example, consider the string "abcßDeF", which case-folds to "abcssdef". This string has the
+ * following fine edits:
+ * <ul>
+ * <li>abc ⇨ abc (no-change)
+ * <li>ß ⇨ ss (change)
+ * <li>D ⇨ d (change)
+ * <li>e ⇨ e (no-change)
+ * <li>F ⇨ f (change)
+ * </ul>
+ * and the following coarse edits (note how adjacent change edits get merged together):
+ * <ul>
+ * <li>abc ⇨ abc (no-change)
+ * <li>ßD ⇨ ssd (change)
+ * <li>e ⇨ e (no-change)
+ * <li>F ⇨ f (change)
+ * </ul>
+ *
+ * The "fine changes" and "coarse changes" iterators will step through only the change edits when their
+ * `Edits::Iterator::next()` methods are called. They are identical to the non-change iterators when
+ * their `Edits::Iterator::findSourceIndex()` or `Edits::Iterator::findDestinationIndex()`
+ * methods are used to walk through the string.
+ *
+ * For examples of how to use this class, see the test `TestCaseMapEditsIteratorDocs` in
+ * UCharacterCaseTest.java.
+ *
+ * An Edits object tracks a separate UErrorCode, but ICU string transformation functions
+ * (e.g., case mapping functions) merge any such errors into their API's UErrorCode.
+ *
+ * @stable ICU 59
+ */
+class U_COMMON_API Edits U_FINAL : public UMemory {
+public:
+    /**
+     * Constructs an empty object.
+     * @stable ICU 59
+     */
+    Edits() :
+            array(stackArray), capacity(STACK_CAPACITY), length(0), delta(0), numChanges(0),
+            errorCode_(U_ZERO_ERROR) {}
+    /**
+     * Copy constructor.
+     * @param other source edits
+     * @stable ICU 60
+     */
+    Edits(const Edits &other) :
+            array(stackArray), capacity(STACK_CAPACITY), length(other.length),
+            delta(other.delta), numChanges(other.numChanges),
+            errorCode_(other.errorCode_) {
+        copyArray(other);
+    }
+    /**
+     * Move constructor, might leave src empty.
+     * This object will have the same contents that the source object had.
+     * @param src source edits
+     * @stable ICU 60
+     */
+    Edits(Edits &&src) U_NOEXCEPT :
+            array(stackArray), capacity(STACK_CAPACITY), length(src.length),
+            delta(src.delta), numChanges(src.numChanges),
+            errorCode_(src.errorCode_) {
+        moveArray(src);
+    }
+
+    /**
+     * Destructor.
+     * @stable ICU 59
+     */
+    ~Edits();
+
+    /**
+     * Assignment operator.
+     * @param other source edits
+     * @return *this
+     * @stable ICU 60
+     */
+    Edits &operator=(const Edits &other);
+
+    /**
+     * Move assignment operator, might leave src empty.
+     * This object will have the same contents that the source object had.
+     * The behavior is undefined if *this and src are the same object.
+     * @param src source edits
+     * @return *this
+     * @stable ICU 60
+     */
+    Edits &operator=(Edits &&src) U_NOEXCEPT;
+
+    /**
+     * Resets the data but may not release memory.
+     * @stable ICU 59
+     */
+    void reset() U_NOEXCEPT;
+
+    /**
+     * Adds a no-change edit: a record for an unchanged segment of text.
+     * Normally called from inside ICU string transformation functions, not user code.
+     * @stable ICU 59
+     */
+    void addUnchanged(int32_t unchangedLength);
+    /**
+     * Adds a change edit: a record for a text replacement/insertion/deletion.
+     * Normally called from inside ICU string transformation functions, not user code.
+     * @stable ICU 59
+     */
+    void addReplace(int32_t oldLength, int32_t newLength);
+    /**
+     * Sets the UErrorCode if an error occurred while recording edits.
+     * Preserves older error codes in the outErrorCode.
+     * Normally called from inside ICU string transformation functions, not user code.
+     * @param outErrorCode Set to an error code if it does not contain one already
+     *                  and an error occurred while recording edits.
+     *                  Otherwise unchanged.
+     * @return TRUE if U_FAILURE(outErrorCode)
+     * @stable ICU 59
+     */
+    UBool copyErrorTo(UErrorCode &outErrorCode) const;
+
+    /**
+     * How much longer is the new text compared with the old text?
+     * @return new length minus old length
+     * @stable ICU 59
+     */
+    int32_t lengthDelta() const { return delta; }
+    /**
+     * @return TRUE if there are any change edits
+     * @stable ICU 59
+     */
+    UBool hasChanges() const { return numChanges != 0; }
+
+    /**
+     * @return the number of change edits
+     * @stable ICU 60
+     */
+    int32_t numberOfChanges() const { return numChanges; }
+
+    /**
+     * Access to the list of edits.
+     *
+     * At any moment in time, an instance of this class points to a single edit: a "window" into a span
+     * of the source string and the corresponding span of the destination string. The source string span
+     * starts at {@link #sourceIndex()} and runs for {@link #oldLength()} chars; the destination string
+     * span starts at {@link #destinationIndex()} and runs for {@link #newLength()} chars.
+     *
+     * The iterator can be moved between edits using the `next()`, `findSourceIndex(int32_t, UErrorCode &)`,
+     * and `findDestinationIndex(int32_t, UErrorCode &)` methods.
+     * Calling any of these methods mutates the iterator to make it point to the corresponding edit.
+     *
+     * For more information, see the documentation for {@link Edits}.
+     *
+     * @see getCoarseIterator
+     * @see getFineIterator
+     * @stable ICU 59
+     */
+    struct U_COMMON_API Iterator U_FINAL : public UMemory {
+        /**
+         * Default constructor, empty iterator.
+         * @stable ICU 60
+         */
+        Iterator() :
+                array(nullptr), index(0), length(0),
+                remaining(0), onlyChanges_(FALSE), coarse(FALSE),
+                dir(0), changed(FALSE), oldLength_(0), newLength_(0),
+                srcIndex(0), replIndex(0), destIndex(0) {}
+        /**
+         * Copy constructor.
+         * @stable ICU 59
+         */
+        Iterator(const Iterator &other) = default;
+        /**
+         * Assignment operator.
+         * @stable ICU 59
+         */
+        Iterator &operator=(const Iterator &other) = default;
+
+        /**
+         * Advances the iterator to the next edit.
+         * @param errorCode ICU error code. Its input value must pass the U_SUCCESS() test,
+         *                  or else the function returns immediately. Check for U_FAILURE()
+         *                  on output or use with function chaining. (See User Guide for details.)
+         * @return TRUE if there is another edit
+         * @stable ICU 59
+         */
+        UBool next(UErrorCode &errorCode) { return next(onlyChanges_, errorCode); }
+
+        /**
+         * Moves the iterator to the edit that contains the source index.
+         * The source index may be found in a no-change edit
+         * even if normal iteration would skip no-change edits.
+         * Normal iteration can continue from a found edit.
+         *
+         * The iterator state before this search logically does not matter.
+         * (It may affect the performance of the search.)
+         *
+         * The iterator state after this search is undefined
+         * if the source index is out of bounds for the source string.
+         *
+         * @param i source index
+         * @param errorCode ICU error code. Its input value must pass the U_SUCCESS() test,
+         *                  or else the function returns immediately. Check for U_FAILURE()
+         *                  on output or use with function chaining. (See User Guide for details.)
+         * @return TRUE if the edit for the source index was found
+         * @stable ICU 59
+         */
+        UBool findSourceIndex(int32_t i, UErrorCode &errorCode) {
+            return findIndex(i, TRUE, errorCode) == 0;
+        }
+
+        /**
+         * Moves the iterator to the edit that contains the destination index.
+         * The destination index may be found in a no-change edit
+         * even if normal iteration would skip no-change edits.
+         * Normal iteration can continue from a found edit.
+         *
+         * The iterator state before this search logically does not matter.
+         * (It may affect the performance of the search.)
+         *
+         * The iterator state after this search is undefined
+         * if the source index is out of bounds for the source string.
+         *
+         * @param i destination index
+         * @param errorCode ICU error code. Its input value must pass the U_SUCCESS() test,
+         *                  or else the function returns immediately. Check for U_FAILURE()
+         *                  on output or use with function chaining. (See User Guide for details.)
+         * @return TRUE if the edit for the destination index was found
+         * @stable ICU 60
+         */
+        UBool findDestinationIndex(int32_t i, UErrorCode &errorCode) {
+            return findIndex(i, FALSE, errorCode) == 0;
+        }
+
+        /**
+         * Computes the destination index corresponding to the given source index.
+         * If the source index is inside a change edit (not at its start),
+         * then the destination index at the end of that edit is returned,
+         * since there is no information about index mapping inside a change edit.
+         *
+         * (This means that indexes to the start and middle of an edit,
+         * for example around a grapheme cluster, are mapped to indexes
+         * encompassing the entire edit.
+         * The alternative, mapping an interior index to the start,
+         * would map such an interval to an empty one.)
+         *
+         * This operation will usually but not always modify this object.
+         * The iterator state after this search is undefined.
+         *
+         * @param i source index
+         * @param errorCode ICU error code. Its input value must pass the U_SUCCESS() test,
+         *                  or else the function returns immediately. Check for U_FAILURE()
+         *                  on output or use with function chaining. (See User Guide for details.)
+         * @return destination index; undefined if i is not 0..string length
+         * @stable ICU 60
+         */
+        int32_t destinationIndexFromSourceIndex(int32_t i, UErrorCode &errorCode);
+
+        /**
+         * Computes the source index corresponding to the given destination index.
+         * If the destination index is inside a change edit (not at its start),
+         * then the source index at the end of that edit is returned,
+         * since there is no information about index mapping inside a change edit.
+         *
+         * (This means that indexes to the start and middle of an edit,
+         * for example around a grapheme cluster, are mapped to indexes
+         * encompassing the entire edit.
+         * The alternative, mapping an interior index to the start,
+         * would map such an interval to an empty one.)
+         *
+         * This operation will usually but not always modify this object.
+         * The iterator state after this search is undefined.
+         *
+         * @param i destination index
+         * @param errorCode ICU error code. Its input value must pass the U_SUCCESS() test,
+         *                  or else the function returns immediately. Check for U_FAILURE()
+         *                  on output or use with function chaining. (See User Guide for details.)
+         * @return source index; undefined if i is not 0..string length
+         * @stable ICU 60
+         */
+        int32_t sourceIndexFromDestinationIndex(int32_t i, UErrorCode &errorCode);
+
+        /**
+         * Returns whether the edit currently represented by the iterator is a change edit.
+         *
+         * @return TRUE if this edit replaces oldLength() units with newLength() different ones.
+         *         FALSE if oldLength units remain unchanged.
+         * @stable ICU 59
+         */
+        UBool hasChange() const { return changed; }
+
+        /**
+         * The length of the current span in the source string, which starts at {@link #sourceIndex}.
+         *
+         * @return the number of units in the original string which are replaced or remain unchanged.
+         * @stable ICU 59
+         */
+        int32_t oldLength() const { return oldLength_; }
+
+        /**
+         * The length of the current span in the destination string, which starts at
+         * {@link #destinationIndex}, or in the replacement string, which starts at
+         * {@link #replacementIndex}.
+         *
+         * @return the number of units in the modified string, if hasChange() is TRUE.
+         *         Same as oldLength if hasChange() is FALSE.
+         * @stable ICU 59
+         */
+        int32_t newLength() const { return newLength_; }
+
+        /**
+         * The start index of the current span in the source string; the span has length
+         * {@link #oldLength}.
+         *
+         * @return the current index into the source string
+         * @stable ICU 59
+         */
+        int32_t sourceIndex() const { return srcIndex; }
+
+        /**
+         * The start index of the current span in the replacement string; the span has length
+         * {@link #newLength}. Well-defined only if the current edit is a change edit.
+         *
+         * The *replacement string* is the concatenation of all substrings of the destination
+         * string corresponding to change edits.
+         *
+         * This method is intended to be used together with operations that write only replacement
+         * characters (e.g. operations specifying the \ref U_OMIT_UNCHANGED_TEXT option).
+         * The source string can then be modified in-place.
+         *
+         * @return the current index into the replacement-characters-only string,
+         *         not counting unchanged spans
+         * @stable ICU 59
+         */
+        int32_t replacementIndex() const {
+            // TODO: Throw an exception if we aren't in a change edit?
+            return replIndex;
+        }
+
+        /**
+         * The start index of the current span in the destination string; the span has length
+         * {@link #newLength}.
+         *
+         * @return the current index into the full destination string
+         * @stable ICU 59
+         */
+        int32_t destinationIndex() const { return destIndex; }
+
+#ifndef U_HIDE_INTERNAL_API
+        /**
+         * A string representation of the current edit represented by the iterator for debugging. You
+         * should not depend on the contents of the return string.
+         * @internal
+         */
+        UnicodeString& toString(UnicodeString& appendTo) const;
+#endif  // U_HIDE_INTERNAL_API
+
+    private:
+        friend class Edits;
+
+        Iterator(const uint16_t *a, int32_t len, UBool oc, UBool crs);
+
+        int32_t readLength(int32_t head);
+        void updateNextIndexes();
+        void updatePreviousIndexes();
+        UBool noNext();
+        UBool next(UBool onlyChanges, UErrorCode &errorCode);
+        UBool previous(UErrorCode &errorCode);
+        /** @return -1: error or i<0; 0: found; 1: i>=string length */
+        int32_t findIndex(int32_t i, UBool findSource, UErrorCode &errorCode);
+
+        const uint16_t *array;
+        int32_t index, length;
+        // 0 if we are not within compressed equal-length changes.
+        // Otherwise the number of remaining changes, including the current one.
+        int32_t remaining;
+        UBool onlyChanges_, coarse;
+
+        int8_t dir;  // iteration direction: back(<0), initial(0), forward(>0)
+        UBool changed;
+        int32_t oldLength_, newLength_;
+        int32_t srcIndex, replIndex, destIndex;
+    };
+
+    /**
+     * Returns an Iterator for coarse-grained change edits
+     * (adjacent change edits are treated as one).
+     * Can be used to perform simple string updates.
+     * Skips no-change edits.
+     * @return an Iterator that merges adjacent changes.
+     * @stable ICU 59
+     */
+    Iterator getCoarseChangesIterator() const {
+        return Iterator(array, length, TRUE, TRUE);
+    }
+
+    /**
+     * Returns an Iterator for coarse-grained change and no-change edits
+     * (adjacent change edits are treated as one).
+     * Can be used to perform simple string updates.
+     * Adjacent change edits are treated as one edit.
+     * @return an Iterator that merges adjacent changes.
+     * @stable ICU 59
+     */
+    Iterator getCoarseIterator() const {
+        return Iterator(array, length, FALSE, TRUE);
+    }
+
+    /**
+     * Returns an Iterator for fine-grained change edits
+     * (full granularity of change edits is retained).
+     * Can be used for modifying styled text.
+     * Skips no-change edits.
+     * @return an Iterator that separates adjacent changes.
+     * @stable ICU 59
+     */
+    Iterator getFineChangesIterator() const {
+        return Iterator(array, length, TRUE, FALSE);
+    }
+
+    /**
+     * Returns an Iterator for fine-grained change and no-change edits
+     * (full granularity of change edits is retained).
+     * Can be used for modifying styled text.
+     * @return an Iterator that separates adjacent changes.
+     * @stable ICU 59
+     */
+    Iterator getFineIterator() const {
+        return Iterator(array, length, FALSE, FALSE);
+    }
+
+    /**
+     * Merges the two input Edits and appends the result to this object.
+     *
+     * Consider two string transformations (for example, normalization and case mapping)
+     * where each records Edits in addition to writing an output string.<br>
+     * Edits ab reflect how substrings of input string a
+     * map to substrings of intermediate string b.<br>
+     * Edits bc reflect how substrings of intermediate string b
+     * map to substrings of output string c.<br>
+     * This function merges ab and bc such that the additional edits
+     * recorded in this object reflect how substrings of input string a
+     * map to substrings of output string c.
+     *
+     * If unrelated Edits are passed in where the output string of the first
+     * has a different length than the input string of the second,
+     * then a U_ILLEGAL_ARGUMENT_ERROR is reported.
+     *
+     * @param ab reflects how substrings of input string a
+     *     map to substrings of intermediate string b.
+     * @param bc reflects how substrings of intermediate string b
+     *     map to substrings of output string c.
+     * @param errorCode ICU error code. Its input value must pass the U_SUCCESS() test,
+     *                  or else the function returns immediately. Check for U_FAILURE()
+     *                  on output or use with function chaining. (See User Guide for details.)
+     * @return *this, with the merged edits appended
+     * @stable ICU 60
+     */
+    Edits &mergeAndAppend(const Edits &ab, const Edits &bc, UErrorCode &errorCode);
+
+private:
+    void releaseArray() U_NOEXCEPT;
+    Edits &copyArray(const Edits &other);
+    Edits &moveArray(Edits &src) U_NOEXCEPT;
+
+    void setLastUnit(int32_t last) { array[length - 1] = (uint16_t)last; }
+    int32_t lastUnit() const { return length > 0 ? array[length - 1] : 0xffff; }
+
+    void append(int32_t r);
+    UBool growArray();
+
+    static const int32_t STACK_CAPACITY = 100;
+    uint16_t *array;
+    int32_t capacity;
+    int32_t length;
+    int32_t delta;
+    int32_t numChanges;
+    UErrorCode errorCode_;
+    uint16_t stackArray[STACK_CAPACITY];
+};
+
+U_NAMESPACE_END
+
+#endif /* U_SHOW_CPLUSPLUS_API */
+
+#endif  // __EDITS_H__