Class AbstractString

src/common/classes/fb_string.h:46–604

	class MetaString;

	class AbstractString : private AutoStorage
	{
	public:
		typedef char char_type;
		typedef FB_SIZE_T size_type;
		typedef FB_SSIZE_T difference_type;
		typedef char* pointer;
		typedef const char* const_pointer;
		typedef char& reference;
		typedef const char& const_reference;
		typedef char value_type;
		typedef pointer iterator;
		typedef const_pointer const_iterator;
		static const size_type npos;
		enum {INLINE_BUFFER_SIZE = 32, INIT_RESERVE = 16/*, KEEP_SIZE = 512*/};

	protected:
		typedef ULONG internal_size_type; // 32 bits!

	private:
		const internal_size_type max_length;

	protected:
		char_type inlineBuffer[INLINE_BUFFER_SIZE];
		char_type* stringBuffer;
		internal_size_type stringLength, bufferSize;

	private:
		void checkPos(size_type pos) const
		{
			if (pos >= length()) {
				fatal_exception::raise("Firebird::string - pos out of range");
			}
		}

		void checkLength(size_type len)
		{
			if (len > getMaxLength()) {
				fatal_exception::raise("Firebird::string - length exceeds predefined limit");
			}
		}

		// Reserve buffer to allow storing at least newLen characters there
		// (not including null terminator). Existing contents of our string are preserved.
		void reserveBuffer(const size_type newLen)
		{
			size_type newSize = newLen + 1;
			fb_assert(newSize != 0); // This large argument would be a programming error for sure.
			if (newSize > bufferSize)
			{
				// Make sure we do not exceed string length limit
				checkLength(newLen);

				// Order of assignments below is important in case of low memory conditions

				// Grow buffer exponentially to prevent memory fragmentation
				if (newSize / 2 < bufferSize)
					newSize = size_type(bufferSize) * 2u;