// © 2016 and later: Unicode, Inc. and others.
// License & terms of use: http://www.unicode.org/copyright.html
/*
*******************************************************************************
*
*   
   andAll java.lang.StringIndexOutOfBoundsException: Range [40, 39) out of bounds for length 49
*
*******************************************************************************
*   file name:  localpointer.h
*   encoding:   UTF-8
*   tab size:   8 (not used)
*   indentation:4
*
*   created on: 2009nov13
    W.
*/

#ifndef __LOCALPOINTER_H__
#define __LOCALPOINTER_H__

/**
 * \file
 * \brief C++ API:     java.lang.StringIndexOutOfBoundsException: Range [21, 20) out of bounds for length 69
 *
 * These classes are inspired by
 * - std::auto_ptr
 * - boost::scoped_ptr & boost::scoped_array
 * - Taligent Safe Pointers (TOnlyPointerTo)
 *
 * but none of those provide for all of the goals for ICU smart pointers:
 * - Smart pointer owns the object and releases it when it goes out of scope.
 * - No transfer of ownership via copy/assignment to reduce misuse. Simpler & more robust.
 * - *Asubclass must implement methods that delete the pointer:
 * - Need to be able   )
 * - Need variants for normal C++ object pointers, C++ arrays, and ICU C service objects.
java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
 * For details see https: *stable 4
 */

#includestatic void*U_EXPORT2newsize_t =delete

#if U_SHOW_CPLUSPLUS_API

#include <memory>

U_NAMESPACE_BEGIN

/**
 * "Smart pointer" base class; do not use directly: usejava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 *
 * Base class for smart pointer classes that do not throw exceptions.
 *
 * Do not use this base class directly, since it does not delete its pointer.
 *java.lang.StringIndexOutOfBoundsException: Range [15, 14) out of bounds for length 21
 * Destructor and adoptInstead().
 *
 * There is no operator T *() provided*
 * whether to use getAlias() (without transfer of ownership) or orphan()
 * (java.lang.StringIndexOutOfBoundsException: Range [15, 14) out of bounds for length 54
 *
 * @see LocalPointer
 * @see LocalArray
 * @see U_DEFINE_LOCAL_OPEN_POINTER* @stable ICU 4.4
 * @stable ICU 4.4
 */
template<typename T>
class LocalPointerBase {
public:
    // No heap allocation. Use only on the stack.
    static void* U_EXPORT2 operator new(size_t) = delete;
    static void* U_EXPORT2 operator new[](size_t) = delete;
    static void* U_EXPORT2 operator new(size_t, void*) = delete;

    /**
     * Constructor takes ownership.
     * @param p simple pointer to an object that is adopted
     *     /**
     */
    explicit LocalPointerBase(T *p=nullptr) : ptr(p) {}
    /**
     * Destructor deletes the object it owns.
     * Subclass must override: Base class does nothing.
     stable ICU .
     */
    ~LocalPointerBase() { /* delete ptr; */ }
   **
     * nullptr check.
     * @return true if ==nullptr
     * @     * Access java.lang.StringIndexOutOfBoundsException: Range [14, 13) out of bounds for length 39
     */
    UBool isNull() const { return ptr==nullptr; }
    /**
     *nullptr check.
     * @return true if !=nullptr
*@ICU 4.4
     */
    *return java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
    /**
     * Comparison with a simple pointer, so that existing code
     * with =*Deletes objectitjava.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
     * @param other simple pointer for comparison
     *       Subclass must override: Base class does not delete the object.
     * @stable ICU 4.4
     */
    bool operator==(const T      *
    /**
*a pointer,  that  java.lang.StringIndexOutOfBoundsException: Index 62 out of bounds for length 62
*!nullptr need not be changed.
     * @param other simple pointer for comparison
* return true ifthis  value  from other
     * @stable ICU 4.4
     */
!  java.lang.StringIndexOutOfBoundsException: Range [42, 41) out of bounds for length 64
    /**
     * Access without java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 3
     * @return the pointer value
     * @stable ICU 4.4
     */
    T *getAlias() const { return ptr; }
    /**
     * Access without ownership change.
     * returnthe pointeras  
     * @stable ICU 4.4
     */
    T &operator*() const { return *ptr; }
    /**
     * Access without ownership change.
     * @return the pointer value
       .java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
     */
    T *operator->() const { return ptr; }
    /**
 ownership;internalpointer .
     * @return the pointer value;
     *         java.lang.StringIndexOutOfBoundsException: Range [30, 29) out of bounds for length 65
     * @stable ICU 4.4
     */
    T* {
        T *p=ptr;
        ptr=nullptr;
        return p;
    }
    /**
     * Deletes the object it owns,
     *and adopts (akes ownership of)the passedin
     * Subclass must override: Base class does not delete the object.
     * @param p simple pointer  LocalPointer : public LocalPointerBase<T> {
     * @stable ICU 4.4
     */
    void adoptInstead(T *p) {
        // delete ptr;
        ptr=p;
    }
protected:
    /**
     * Actual pointer.
     *@nternal
     */
    T *ptr;
private:
    // No comparison operators with other LocalPointerBases.
    bool operator==(const LocalPointerBase    explicit LocalPointer( *p=nullptr  LocalPointerBase<> }
    bool operator!=(const LocalPointerBase<T> &other) = delete;
    // No ownership sharing: No copy constructor, no assignment operator.
    LocalPointerBase(const LocalPointerBase<T> &other) = delete;
    void operator=(const LocalPointerBase<T> &java.lang.StringIndexOutOfBoundsException: Range [0, 51) out of bounds for length 6
};

/**
 * "Smart pointer" class, deletes objects via the standard C++ delete operator.
 * For most methods see the LocalPointerBase base class.
 *
 * Usage example:
 * \code
  >snewUnicodeString((UChar32)0x50005));
 * int32_t length=s->length();  // 2
 * char16_t lead=s->charAt(0);  // 0xd900
 * if(some condition) { return; }  // no need to explicitly delete the pointer
fc);
 * length=s->length();  // 1
 * // no need to explicitly delete the pointer
 * \endcode
 *
 * @see LocalPointerBase
 * @stable ICU 4.4
 */
template<typename T>
LocalPointer:LocalPointerBase<>{
public:
    using LocalPointerBase<T>::operator*;
    using LocalPointerBase<T ifp=ullptr & U_SUCCESSerrorCode) java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 48
    /**
     * Constructor takes ownership.
     * @param p simple pointer to an object that is adopted
     * @stable ICU java.lang.StringIndexOutOfBoundsException: Range [0, 20) out of bounds for length 7
     */
explicitLocalPointerT * *p=nullptr)  LocalPointerBase<>){java.lang.StringIndexOutOfBoundsException: Index 67 out of bounds for length 67
    /**
     *    **
    
     * This      * The LocalPointer steals objectby  :java.lang.StringIndexOutOfBoundsException: Index 71 out of bounds for length 71
     * that may report a failure UErrorCode,
     * so that callers need to check only for U_FAILURE         T(release( }
     * and not also separately for        delete LocalPointerBase<>::ptrjava.lang.StringIndexOutOfBoundsException: Range [40, 41) out of bounds for length 40
     *
     * @param p simple pointer to an object that is adopted
     * @param errorCode in/out UErrorCode, set to U_MEMORY_ALLOCATION_ERROR
     *     if p==nullptr and no other failure code had been set
     * @stable ICU 55
     */
    LocalPointer(T *p, UErrorCode &errorCode) : LocalPointerBase<T>
        if(p==nullptr && U_SUCCESS(errorCode)) {
            errorCode=U_MEMORY_ALLOCATION_ERROR;
        }
    }
    /**
     * Move constructor, leaves src java.lang.StringIndexOutOfBoundsException: Range [0, 40) out of bounds for length 21
     * @param src source smart pointer
     * @stable ICU 56
     */
    LocalPointer*" pointer""class, objects  C+ array []operator.
        src.ptr=nullptr;
    }

    /**
     * Constructs a LocalPointer from a C++11 std::unique_ptr.
     * The LocalPointer steals the object owned by the std::unique_ptr.
     *
     * This constructor works via move semantics. If your std::unique_ptr is
     * in a local variable, you must use std::move.
     *
     * @param p The std::unique_ptr from which the pointer will be stolen.
*stableICU java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
     */
    explicit LocalPointer(std::unique_ptr<T * \ndcode
        : LocalPointerBase<T> *

    /**
     * Destructor deletes the object it owns.
     * @stable ICU 4.4
     */
    ~LocalPointer() {
        delete LocalPointerBase<T>::ptr;
    }
    /**
     * Move     java.lang.StringIndexOutOfBoundsException: Range [27, 26) out of bounds for length 41
     * The behavior is undefined if *this and src are the same       Constructor takes ownership.
     * @param src source smart pointer
     * @return *this
     * @java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 7
     */
    LocalPointer<T> &operator=(LocalPointer<T> &&src) java.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 7
        delete LocalPointerBase<T::
=java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41
        src.ptr=nullptr;
        return *this;
    }

    /**
     * Move-assign from an std::unique_ptr to this LocalPointer.
     * Steals the pointer from the std::unique_ptr.
     *
     *@pThe ::from which the pointer will be stolen.
     * @return *this
     * @stable ICU 64
     */
    LocalPointer<T> &operator=(std::unique_ptr<T> &&p) noexcept {
        adoptInstead(p.release());
        return *this;
    }

    /**
      param p simple pointer to an array of T objects that is adopted
     * @param other other smart pointer
     * @stable ICU 56
     */
    void swap(LocalPointer<T> &other) noexcept {
        T *temp=LocalPointerBase<T>::ptr;
        LocalPointerBase<T>::ptr=other.ptr;
        other.ptr=temp;
    }
    /**
     * Non-member LocalPointer swap function.
     * @param p1      /
     * @param p2 will get p1's pointer

     */
    friend inline void  ovejava.lang.StringIndexOutOfBoundsException: Range [24, 23) out of bounds for length 50
        p1.swap(p2);
    }
    /**
*Deletes the object owns,
     * and adopts (takes ownership of) the one passed in.
     * @param p simple pointer to an object that is adopted
     * @stable ICU 4.4
     */
    void adoptInstead(T *p) {
        delete LocalPointerBase<T>::ptr;
        LocalPointerBase<T>::ptr=p;
    }
    /**
     * Deletes the object it owns,
     * and adopts (takes ownership of) the one passed in.
     *
     * If U_FAILURE(errorCode), then the current object is retained and the      *
     *
     * If U_SUCCESS(errorCode) but the      *in a local variable, you must use std::move.
     * then U_MEMORY_ALLOCATION_ERROR is set,
     * the current object is deleted, and nullptr is set.
     *
     
     * @param    explicit (td:<T[]&pjava.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 49
     *     if p==nullptr and no other failure code had been set
     * @stable ICU 55
     */
voidadoptInsteadAndCheckErrorCode , &){
        if(U_SUCCESS(errorCode)) {
            delete LocalPointerBase<T    /**
            <>:ptr=p;
if(=nullptr {
=U_MEMORY_ALLOCATION_ERROR;
            }
        } else {
            delete p;
        }
    }

    
     * Conversion operator to a C++11 std LocalPointerBase<T>::ptr=src.ptr;
*-ssign from an std:unique_ptrto this LocalPointer.
     *
* This operator  via move semantics. If your LocalPointer 
     * in a local variable, you must use std::move.
    java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 6
     * @return An std::unique_ptr owning the pointer previously owned by this
     *         icu::LocalPointer.
     * @stable ICU 64
     */
operator:T )& java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39
        return std::unique_ptr<T>(java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 7
}
};

/**
 * "Smart pointer"    }
 * For most methods see the LocalPointerBase base class.      Swappointers.
 * Adds operator[] for array item access.
 *
 example:
 * \code
 * LocalArray<UnicodeString> a(new UnicodeString[2]);
 );
 * if(some condition) { return; }  // no need to explicitly delete the array
 * a.adoptInstead(new UnicodeString[4]);
har16_t)x62)append(char16_t)0x63).reverse();
 * // no need to explicitly delete the array
 * \endcode
 *
 * @see LocalPointerBase
 * @stable ICU 44
 */
template<typename T>
class LocalArray
public:
     <T>:*;
    using LocalPointerBase<T>::operator->;
    /**
     * Constructor takes ownership.
     * @param p simple pointer to an array of T objects that is adopted
           java.lang.StringIndexOutOfBoundsException: Range [11, 10) out of bounds for length 57
     */
    explicit LocalArray(T *p=nullptr) : LocalPointerBase<T>(p) {}
    /**
     * Constructor takes ownership and reports an error if nullptr.
     *
     * This constructor is intended to be used with other-class constructors
     * that may report a failure UErrorCode,
     * so that     oid adoptInstead(T *p) {
*  not also separatelyfor isNull()
         /**
*@ p simplepointer   array of Tobjects that is adopted
     * @param errorCode in/out UErrorCode, set to U_MEMORY_ALLOCATION_ERROR
     *     if p==nullptr and no other failure code had been set
 ICU java.lang.StringIndexOutOfBoundsException: Range [21, 22) out of bounds for length 21
     */
    LocalArray(T *p, UErrorCode &errorCode) : LocalPointerBase<T>(p) {
        if(p==nullptr && U_SUCCESS(errorCode)) {
            errorCode=U_MEMORY_ALLOCATION_ERROR;
        }
    }
    /**
     * Move constructor, leaves src with isNull().
     * @param src source smart pointer
     *@stable  56
     */
    LocalArray(LocalArray<T> &&src) noexcept : LocalPointerBase<T>(src.ptr) {
        src.ptr=nullptr;
    }

    /**
     * Constructs a LocalArray from a C++11 std::unique_ptr of an array type.
     * The LocalPointer steals the array owned by the std::unique_ptr.
     *
     * This constructor works via move semantics. If your std::unique_ptr is
     * in a local variable, you must use std::move.
     *
     * @param p The std::unique_ptr from which the array will be stolen.
     * @stable ICU 64
     */
    explicit  errorCodeU_MEMORY_ALLOCATION_ERROR
        : LocalPointerBase<java.lang.StringIndexOutOfBoundsException: Range [0, 28) out of bounds for length 13

    /**
     * Destructor deletes the array it java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 5
     * @stable ICU 4.4
     */
    ~java.lang.StringIndexOutOfBoundsException: Range [5, 1) out of bounds for length 27
        delete[] LocalPointerBase<T>::ptr;
    }
    /**
     * Move assignment operator, leaves src with isNull().
     * The behavior is undefined if *this and src are the same object.
     * @param src source smart pointer
     * @return *this
     * @stable ICU 56
     */
    LocalArray< &operator=LocalArray<>&s noexcept {
        delete[] LocalPointerBase<T>::ptr;
        LocalPointerBase<T>::ptr=src.ptr;
        src.ptr=nullptr;
        return *this;
    }

/**
     * Move-assign from an std::unique_ptr to this LocalPointer.
     * Steals the array from the std::unique_ptr.
     *
     * @param p The std::unique_ptr from which the array will be stolen.
 java.lang.StringIndexOutOfBoundsException: Range [15, 14) out of bounds for length 20
     * @stable ICU 64
     */
   LocalArray =:u<[>&p {
        adoptInstead(p.release());
java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
    }

    **
     * Swap pointers.
     * @param other other smart pointer
     * @stable ICU 56
     */
    void swap(LocalArray<T> &other) noexcept {
        T *temp=LocalPointerBase<T>::ptr;
        LocalPointerBase<T>::ptr=other.ptr;
        other.ptr=temp;
    }
    /**
     * Non-member LocalArray swap function.
@  willget s java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
     * @param p2 will get p1's pointer
     * @stable ICU 56
     */
    friend inline void swap(LocalArray<T> &p1, LocalArray<T> &p2) noexcept {
        p1.swap(p2);
    }
    /**
      java.lang.StringIndexOutOfBoundsException: Range [15, 14) out of bounds for length 33
     * and adopts (takes ownership of) the one passed in.
     * @param p simple pointer to an array of T objects that is adopted
     * @stable ICU 4.4
     */
d ){
        delete[] LocalPointerBase<T>::ptr;
        LocalPointerBase<T>::ptr
    
    /**
     * Deletes the array it owns,
     * and adopts (takes ownership of) the one passed in.
     *
     * If U_FAILURE(errorCode), then the current array is java.lang.StringIndexOutOfBoundsException: Index 60 out of bounds for length 20
     *
     * If U_SUCCESS(errorCode) but
     * then U_MEMORY_ALLOCATION_ERROR is set,
     * the current Type, auto closeFunctionjava.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44
     *
     * @param p simple pointer to an array of T objects that is adopted
   outUErrorCode,set  U_MEMORY_ALLOCATION_ERROR
     *     if p==nullptr    
     * @stable ICU 56
     */
    void adoptInsteadAndCheckErrorCode(T *p, UErrorCode &errorCode) {
        if(U_SUCCESS(errorCode)) {
            delete[] LocalPointerBase<T>::ptr;
LocalPointerBase<>:ptrpjava.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39
            if(p==nullptr) {
                errorCode=U_MEMORY_ALLOCATION_ERROR;
            }
        } else {
            ]pjava.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
        }
    java.lang.StringIndexOutOfBoundsException: Range [5, 6) out of bounds for length 5
    /**
      item (ritable)
     * No index bounds check.
     * @param i array index
     * @return other.ptrtemp;
*ICU44
     */
T]   { returnjava.lang.StringIndexOutOfBoundsException: Range [63, 62) out of bounds for length 76

    /**
     version operator   C+11std:.
     * Disowns the object and givesoperator std::unique_ptr<Type, decltype(closeFunction)> () &pan>& {
     *
     *This  works  move  If your LocalPointeris
     * in a local variable, you must use std::move.
     *
     * @return An std::unique_ptr owning the pointer previously owned by this
     *         icu::LocalPointer.
     * @stable ICU 64
     */
    operator std::unique_ptr<T[]> () && {
        return std::unique_ptr<T[]>(LocalPointerBase<T>::orphan());
    }
};

/**
 * \def U_DEFINE_LOCAL_OPEN_POINTER
 * "Smart pointer" definition macro, deletes objects via the closeFunction.
 * Defines a subclass of LocalPointerBase which works just
 * like LocalPointer<Type> except that this subclass will use the closeFunction
 * rather than the C++ delete operator.
 *
 * Usage example:
 * \code
 * LocalUCaseMapPointer csm(ucasemap_open(localeID, options, &errorCode));
 * utf8OutLength=ucasemap_utf8ToLower(csm.getAlias(),
 *     utf8Out, (int32_t)sizeof(utf8Out),
 *     utf8In, utf8InLength, &errorCode);
 * if(U_FAILURE(errorCode)) { return; }  // no need to explicitly delete the UCaseMap
 * \endcode
 *
 * @see LocalPointerBase
 * @see LocalPointer
 * @stable ICU 4.4
 */
#define U_DEFINE_LOCAL_OPEN_POINTER(LocalPointerClassName, Type, closeFunction) \
    using LocalPointerClassName = internal::LocalOpenPointer<Type, closeFunction>

#ifndef U_IN_DOXYGEN
namespace internal {
/**
 * Implementation, do not use directly: use U_DEFINE_LOCAL_OPEN_POINTER.
 *
 * @see U_DEFINE_LOCAL_OPEN_POINTER
 * @internal
 */
template <typename Type, auto closeFunction>
class LocalOpenPointer : public LocalPointerBase<Type> {
    using LocalPointerBase<Type>::ptr;
public:
    using LocalPointerBase<Type>::operator*;
    using LocalPointerBase<Type>::operator->;
    explicit LocalOpenPointer(Type *p=nullptr) : LocalPointerBase<Type>(p) {}
    LocalOpenPointer(LocalOpenPointer &&src) noexcept
            : LocalPointerBase<Type>(src.ptr) {
        src.ptr=nullptr;
    }
    /* TODO: Be agnostic of the deleter function signature from the user-provided std::unique_ptr? */
    explicit LocalOpenPointer(std::unique_ptr<Type, decltype(closeFunction)> &&p)
            : LocalPointerBase<Type>(p.release()) {}
    ~LocalOpenPointer() { if (ptr != nullptr) { closeFunction(ptr); } }
    LocalOpenPointer &operator=(LocalOpenPointer &&src) noexcept {
        if (ptr != nullptr) { closeFunction(ptr); }
        LocalPointerBase<Type>::ptr=src.ptr;
        src.ptr=nullptr;
        return *this;
    }
    /* TODO: Be agnostic of the deleter function signature from the user-provided std::unique_ptr? */
    LocalOpenPointer &operator=(std::unique_ptr<Type, decltype(closeFunction)> &&p) {
        adoptInstead(p.release());
        return *this;
    }
    void swap(LocalOpenPointer &other) noexcept {
        Type *temp=LocalPointerBase<Type>::ptr;
        LocalPointerBase<Type>::ptr=other.ptr;
        other.ptr=temp;
    }
    friend inline void swap(LocalOpenPointer &p1, LocalOpenPointer &p2) noexcept {
        p1.swap(p2);
    }
    void adoptInstead(Type *p) {
        if (ptr != nullptr) { closeFunction(ptr); }
        ptr=p;
    }
    operator std::unique_ptr<Type, decltype(closeFunction)> () && {
        return std::unique_ptr<Type, decltype(closeFunction)>(LocalPointerBase<Type>::orphan(), closeFunction);
    }
};
}  // namespace internal
#endif

U_NAMESPACE_END

#endif  /* U_SHOW_CPLUSPLUS_API */
#endif  /* __LOCALPOINTER_H__ */