include/utils/String16.h - aosp/platform/system/core/libutils - Git at Google

 /*
  * Copyright (C) 2005 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *      http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */

 #ifndef ANDROID_STRING16_H
 #define ANDROID_STRING16_H

 #include <iostream>
 #include <string>

 #include <utils/Errors.h>
 #include <utils/String8.h>
 #include <utils/TypeHelpers.h>

 // ---------------------------------------------------------------------------

 namespace android {

 // ---------------------------------------------------------------------------

 template <size_t N>
 class StaticString16;

 // DO NOT USE: please use std::u16string

 //! This is a string holding UTF-16 characters.
 class String16
 {
 public:
                                 String16();
                                 String16(const String16& o);
                                 String16(String16&& o) noexcept;
                                 String16(const String16& o,
                                          size_t len,
                                          size_t begin=0);
     explicit                    String16(const char16_t* o);
     explicit                    String16(const char16_t* o, size_t len);
     explicit                    String16(const String8& o);
     explicit                    String16(const char* o);
     explicit                    String16(const char* o, size_t len);

                                 ~String16();

     inline  const char16_t*     string() const;

 private:
     static inline std::string   std_string(const String16& str);
 public:
             size_t              size() const;
             void                setTo(const String16& other);
             status_t            setTo(const char16_t* other);
             status_t            setTo(const char16_t* other, size_t len);
             status_t            setTo(const String16& other,
                                       size_t len,
                                       size_t begin=0);

             status_t            append(const String16& other);
             status_t            append(const char16_t* other, size_t len);

     inline  String16&           operator=(const String16& other);
             String16&           operator=(String16&& other) noexcept;

     inline  String16&           operator+=(const String16& other);
     inline  String16            operator+(const String16& other) const;

             status_t            insert(size_t pos, const char16_t* chrs);
             status_t            insert(size_t pos,
                                        const char16_t* chrs, size_t len);

             ssize_t             findFirst(char16_t c) const;
             ssize_t             findLast(char16_t c) const;

             bool                startsWith(const String16& prefix) const;
             bool                startsWith(const char16_t* prefix) const;

             bool                contains(const char16_t* chrs) const;

             status_t            replaceAll(char16_t replaceThis,
                                            char16_t withThis);

     inline  int                 compare(const String16& other) const;

     inline  bool                operator<(const String16& other) const;
     inline  bool                operator<=(const String16& other) const;
     inline  bool                operator==(const String16& other) const;
     inline  bool                operator!=(const String16& other) const;
     inline  bool                operator>=(const String16& other) const;
     inline  bool                operator>(const String16& other) const;

     inline  bool                operator<(const char16_t* other) const;
     inline  bool                operator<=(const char16_t* other) const;
     inline  bool                operator==(const char16_t* other) const;
     inline  bool                operator!=(const char16_t* other) const;
     inline  bool                operator>=(const char16_t* other) const;
     inline  bool                operator>(const char16_t* other) const;

     inline                      operator const char16_t*() const;

     // Static and non-static String16 behave the same for the users, so
     // this method isn't of much use for the users. It is public for testing.
             bool                isStaticString() const;

   private:
     /*
      * A flag indicating the type of underlying buffer.
      */
     static constexpr uint32_t kIsSharedBufferAllocated = 0x80000000;

     /*
      * alloc() returns void* so that SharedBuffer class is not exposed.
      */
     static void* alloc(size_t size);
     static char16_t* allocFromUTF8(const char* u8str, size_t u8len);
     static char16_t* allocFromUTF16(const char16_t* u16str, size_t u16len);

     /*
      * edit() and editResize() return void* so that SharedBuffer class
      * is not exposed.
      */
     void* edit();
     void* editResize(size_t new_size);

     void acquire();
     void release();

     size_t staticStringSize() const;

     const char16_t* mString;

 protected:
     /*
      * Data structure used to allocate static storage for static String16.
      *
      * Note that this data structure and SharedBuffer are used interchangably
      * as the underlying data structure for a String16.  Therefore, the layout
      * of this data structure must match the part in SharedBuffer that is
      * visible to String16.
      */
     template <size_t N>
     struct StaticData {
         // The high bit of 'size' is used as a flag.
         static_assert(N - 1 < kIsSharedBufferAllocated, "StaticString16 too long!");
         constexpr StaticData() : size(N - 1), data{0} {}
         const uint32_t size;
         char16_t data[N];

         constexpr StaticData(const StaticData<N>&) = default;
     };

     /*
      * Helper function for constructing a StaticData object.
      */
     template <size_t N>
     static constexpr const StaticData<N> makeStaticData(const char16_t (&s)[N]) {
         StaticData<N> r;
         // The 'size' field is at the same location where mClientMetadata would
         // be for a SharedBuffer.  We do NOT set kIsSharedBufferAllocated flag
         // here.
         for (size_t i = 0; i < N - 1; ++i) r.data[i] = s[i];
         return r;
     }

     template <size_t N>
     explicit constexpr String16(const StaticData<N>& s) : mString(s.data) {}
 };

 // String16 can be trivially moved using memcpy() because moving does not
 // require any change to the underlying SharedBuffer contents or reference count.
 ANDROID_TRIVIAL_MOVE_TRAIT(String16)

 static inline std::ostream& operator<<(std::ostream& os, const String16& str) {
     os << String8(str);
     return os;
 }

 // ---------------------------------------------------------------------------

 /*
  * A StaticString16 object is a specialized String16 object.  Instead of holding
  * the string data in a ref counted SharedBuffer object, it holds data in a
  * buffer within StaticString16 itself.  Note that this buffer is NOT ref
  * counted and is assumed to be available for as long as there is at least a
  * String16 object using it.  Therefore, one must be extra careful to NEVER
  * assign a StaticString16 to a String16 that outlives the StaticString16
  * object.
  *
  * THE SAFEST APPROACH IS TO USE StaticString16 ONLY AS GLOBAL VARIABLES.
  *
  * A StaticString16 SHOULD NEVER APPEAR IN APIs.  USE String16 INSTEAD.
  */
 template <size_t N>
 class StaticString16 : public String16 {
 public:
     constexpr StaticString16(const char16_t (&s)[N]) : String16(mData), mData(makeStaticData(s)) {}

     constexpr StaticString16(const StaticString16<N>& other)
         : String16(mData), mData(other.mData) {}

     constexpr StaticString16(const StaticString16<N>&&) = delete;

     // There is no reason why one would want to 'new' a StaticString16.  Delete
     // it to discourage misuse.
     static void* operator new(std::size_t) = delete;

 private:
     const StaticData<N> mData;
 };

 template <typename F>
 StaticString16(const F&)->StaticString16<sizeof(F) / sizeof(char16_t)>;

 // ---------------------------------------------------------------------------
 // No user servicable parts below.

 inline int compare_type(const String16& lhs, const String16& rhs)
 {
     return lhs.compare(rhs);
 }

 inline int strictly_order_type(const String16& lhs, const String16& rhs)
 {
     return compare_type(lhs, rhs) < 0;
 }

 inline const char16_t* String16::string() const
 {
     return mString;
 }

 inline std::string String16::std_string(const String16& str)
 {
     return std::string(String8(str).string());
 }

 inline String16& String16::operator=(const String16& other)
 {
     setTo(other);
     return *this;
 }

 inline String16& String16::operator+=(const String16& other)
 {
     append(other);
     return *this;
 }

 inline String16 String16::operator+(const String16& other) const
 {
     String16 tmp(*this);
     tmp += other;
     return tmp;
 }

 inline int String16::compare(const String16& other) const
 {
     return strzcmp16(mString, size(), other.mString, other.size());
 }

 inline bool String16::operator<(const String16& other) const
 {
     return strzcmp16(mString, size(), other.mString, other.size()) < 0;
 }

 inline bool String16::operator<=(const String16& other) const
 {
     return strzcmp16(mString, size(), other.mString, other.size()) <= 0;
 }

 inline bool String16::operator==(const String16& other) const
 {
     return strzcmp16(mString, size(), other.mString, other.size()) == 0;
 }

 inline bool String16::operator!=(const String16& other) const
 {
     return strzcmp16(mString, size(), other.mString, other.size()) != 0;
 }

 inline bool String16::operator>=(const String16& other) const
 {
     return strzcmp16(mString, size(), other.mString, other.size()) >= 0;
 }

 inline bool String16::operator>(const String16& other) const
 {
     return strzcmp16(mString, size(), other.mString, other.size()) > 0;
 }

 inline bool String16::operator<(const char16_t* other) const
 {
     return strcmp16(mString, other) < 0;
 }

 inline bool String16::operator<=(const char16_t* other) const
 {
     return strcmp16(mString, other) <= 0;
 }

 inline bool String16::operator==(const char16_t* other) const
 {
     return strcmp16(mString, other) == 0;
 }

 inline bool String16::operator!=(const char16_t* other) const
 {
     return strcmp16(mString, other) != 0;
 }

 inline bool String16::operator>=(const char16_t* other) const
 {
     return strcmp16(mString, other) >= 0;
 }

 inline bool String16::operator>(const char16_t* other) const
 {
     return strcmp16(mString, other) > 0;
 }

 inline String16::operator const char16_t*() const
 {
     return mString;
 }

 }  // namespace android

 // ---------------------------------------------------------------------------

 #endif // ANDROID_STRING16_H
	/*
	* Copyright (C) 2005 The Android Open Source Project
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

	#ifndef ANDROID_STRING16_H
	#define ANDROID_STRING16_H

	#include <iostream>
	#include <string>

	#include <utils/Errors.h>
	#include <utils/String8.h>
	#include <utils/TypeHelpers.h>

	// ---------------------------------------------------------------------------

	namespace android {

	// ---------------------------------------------------------------------------

	template <size_t N>
	class StaticString16;

	// DO NOT USE: please use std::u16string

	//! This is a string holding UTF-16 characters.
	class String16
	{
	public:
	String16();
	String16(const String16& o);
	String16(String16&& o) noexcept;
	String16(const String16& o,
	size_t len,
	size_t begin=0);
	explicit String16(const char16_t* o);
	explicit String16(const char16_t* o, size_t len);
	explicit String16(const String8& o);
	explicit String16(const char* o);
	explicit String16(const char* o, size_t len);

	~String16();

	inline const char16_t* string() const;

	private:
	static inline std::string std_string(const String16& str);
	public:
	size_t size() const;
	void setTo(const String16& other);
	status_t setTo(const char16_t* other);
	status_t setTo(const char16_t* other, size_t len);
	status_t setTo(const String16& other,
	size_t len,
	size_t begin=0);

	status_t append(const String16& other);
	status_t append(const char16_t* other, size_t len);

	inline String16& operator=(const String16& other);
	String16& operator=(String16&& other) noexcept;

	inline String16& operator+=(const String16& other);
	inline String16 operator+(const String16& other) const;

	status_t insert(size_t pos, const char16_t* chrs);
	status_t insert(size_t pos,
	const char16_t* chrs, size_t len);

	ssize_t findFirst(char16_t c) const;
	ssize_t findLast(char16_t c) const;

	bool startsWith(const String16& prefix) const;
	bool startsWith(const char16_t* prefix) const;

	bool contains(const char16_t* chrs) const;

	status_t replaceAll(char16_t replaceThis,
	char16_t withThis);

	inline int compare(const String16& other) const;

	inline bool operator<(const String16& other) const;
	inline bool operator<=(const String16& other) const;
	inline bool operator==(const String16& other) const;
	inline bool operator!=(const String16& other) const;
	inline bool operator>=(const String16& other) const;
	inline bool operator>(const String16& other) const;

	inline bool operator<(const char16_t* other) const;
	inline bool operator<=(const char16_t* other) const;
	inline bool operator==(const char16_t* other) const;
	inline bool operator!=(const char16_t* other) const;
	inline bool operator>=(const char16_t* other) const;
	inline bool operator>(const char16_t* other) const;

	inline operator const char16_t*() const;

	// Static and non-static String16 behave the same for the users, so
	// this method isn't of much use for the users. It is public for testing.
	bool isStaticString() const;

	private:
	/*
	* A flag indicating the type of underlying buffer.
	*/
	static constexpr uint32_t kIsSharedBufferAllocated = 0x80000000;

	/*
	* alloc() returns void* so that SharedBuffer class is not exposed.
	*/
	static void* alloc(size_t size);
	static char16_t* allocFromUTF8(const char* u8str, size_t u8len);
	static char16_t* allocFromUTF16(const char16_t* u16str, size_t u16len);

	/*
	* edit() and editResize() return void* so that SharedBuffer class
	* is not exposed.
	*/
	void* edit();
	void* editResize(size_t new_size);

	void acquire();
	void release();

	size_t staticStringSize() const;

	const char16_t* mString;

	protected:
	/*
	* Data structure used to allocate static storage for static String16.
	*
	* Note that this data structure and SharedBuffer are used interchangably
	* as the underlying data structure for a String16. Therefore, the layout
	* of this data structure must match the part in SharedBuffer that is
	* visible to String16.
	*/
	template <size_t N>
	struct StaticData {
	// The high bit of 'size' is used as a flag.
	static_assert(N - 1 < kIsSharedBufferAllocated, "StaticString16 too long!");
	constexpr StaticData() : size(N - 1), data{0} {}
	const uint32_t size;
	char16_t data[N];

	constexpr StaticData(const StaticData<N>&) = default;
	};

	/*
	* Helper function for constructing a StaticData object.
	*/
	template <size_t N>
	static constexpr const StaticData<N> makeStaticData(const char16_t (&s)[N]) {
	StaticData<N> r;
	// The 'size' field is at the same location where mClientMetadata would
	// be for a SharedBuffer. We do NOT set kIsSharedBufferAllocated flag
	// here.
	for (size_t i = 0; i < N - 1; ++i) r.data[i] = s[i];
	return r;
	}

	template <size_t N>
	explicit constexpr String16(const StaticData<N>& s) : mString(s.data) {}
	};

	// String16 can be trivially moved using memcpy() because moving does not
	// require any change to the underlying SharedBuffer contents or reference count.
	ANDROID_TRIVIAL_MOVE_TRAIT(String16)

	static inline std::ostream& operator<<(std::ostream& os, const String16& str) {
	os << String8(str);
	return os;
	}

	// ---------------------------------------------------------------------------

	/*
	* A StaticString16 object is a specialized String16 object. Instead of holding
	* the string data in a ref counted SharedBuffer object, it holds data in a
	* buffer within StaticString16 itself. Note that this buffer is NOT ref
	* counted and is assumed to be available for as long as there is at least a
	* String16 object using it. Therefore, one must be extra careful to NEVER
	* assign a StaticString16 to a String16 that outlives the StaticString16
	* object.
	*
	* THE SAFEST APPROACH IS TO USE StaticString16 ONLY AS GLOBAL VARIABLES.
	*
	* A StaticString16 SHOULD NEVER APPEAR IN APIs. USE String16 INSTEAD.
	*/
	template <size_t N>
	class StaticString16 : public String16 {
	public:
	constexpr StaticString16(const char16_t (&s)[N]) : String16(mData), mData(makeStaticData(s)) {}

	constexpr StaticString16(const StaticString16<N>& other)
	: String16(mData), mData(other.mData) {}

	constexpr StaticString16(const StaticString16<N>&&) = delete;

	// There is no reason why one would want to 'new' a StaticString16. Delete
	// it to discourage misuse.
	static void* operator new(std::size_t) = delete;

	private:
	const StaticData<N> mData;
	};

	template <typename F>
	StaticString16(const F&)->StaticString16<sizeof(F) / sizeof(char16_t)>;

	// ---------------------------------------------------------------------------
	// No user servicable parts below.

	inline int compare_type(const String16& lhs, const String16& rhs)
	{
	return lhs.compare(rhs);
	}

	inline int strictly_order_type(const String16& lhs, const String16& rhs)
	{
	return compare_type(lhs, rhs) < 0;
	}

	inline const char16_t* String16::string() const
	{
	return mString;
	}

	inline std::string String16::std_string(const String16& str)
	{
	return std::string(String8(str).string());
	}

	inline String16& String16::operator=(const String16& other)
	{
	setTo(other);
	return *this;
	}

	inline String16& String16::operator+=(const String16& other)
	{
	append(other);
	return *this;
	}

	inline String16 String16::operator+(const String16& other) const
	{
	String16 tmp(*this);
	tmp += other;
	return tmp;
	}

	inline int String16::compare(const String16& other) const
	{
	return strzcmp16(mString, size(), other.mString, other.size());
	}

	inline bool String16::operator<(const String16& other) const
	{
	return strzcmp16(mString, size(), other.mString, other.size()) < 0;
	}

	inline bool String16::operator<=(const String16& other) const
	{
	return strzcmp16(mString, size(), other.mString, other.size()) <= 0;
	}

	inline bool String16::operator==(const String16& other) const
	{
	return strzcmp16(mString, size(), other.mString, other.size()) == 0;
	}

	inline bool String16::operator!=(const String16& other) const
	{
	return strzcmp16(mString, size(), other.mString, other.size()) != 0;
	}

	inline bool String16::operator>=(const String16& other) const
	{
	return strzcmp16(mString, size(), other.mString, other.size()) >= 0;
	}

	inline bool String16::operator>(const String16& other) const
	{
	return strzcmp16(mString, size(), other.mString, other.size()) > 0;
	}

	inline bool String16::operator<(const char16_t* other) const
	{
	return strcmp16(mString, other) < 0;
	}

	inline bool String16::operator<=(const char16_t* other) const
	{
	return strcmp16(mString, other) <= 0;
	}

	inline bool String16::operator==(const char16_t* other) const
	{
	return strcmp16(mString, other) == 0;
	}

	inline bool String16::operator!=(const char16_t* other) const
	{
	return strcmp16(mString, other) != 0;
	}

	inline bool String16::operator>=(const char16_t* other) const
	{
	return strcmp16(mString, other) >= 0;
	}

	inline bool String16::operator>(const char16_t* other) const
	{
	return strcmp16(mString, other) > 0;
	}

	inline String16::operator const char16_t*() const
	{
	return mString;
	}

	} // namespace android

	// ---------------------------------------------------------------------------

	#endif // ANDROID_STRING16_H