NEVER_INLINE unsigned StringImpl::hashSlowCase() const { if (is8Bit()) setHash(StringHasher::computeHashAndMaskTop8Bits(characters8(), m_length)); else setHash(StringHasher::computeHashAndMaskTop8Bits(characters16(), m_length)); return existingHash(); }
void String::append(const UChar* charactersToAppend, unsigned lengthToAppend) { if (!m_impl) { if (!charactersToAppend) return; m_impl = StringImpl::create(charactersToAppend, lengthToAppend); return; } if (!lengthToAppend) return; unsigned strLength = m_impl->length(); ASSERT(charactersToAppend); RELEASE_ASSERT(lengthToAppend <= std::numeric_limits<unsigned>::max() - strLength); UChar* data; RefPtr<StringImpl> newImpl = StringImpl::createUninitialized(strLength + lengthToAppend, data); if (m_impl->is8Bit()) StringImpl::copyChars(data, characters8(), strLength); else StringImpl::copyChars(data, characters16(), strLength); StringImpl::copyChars(data + strLength, charactersToAppend, lengthToAppend); m_impl = newImpl.release(); }
unsigned String::copyTo(UChar* buffer, unsigned pos, unsigned maxLength) const { unsigned length = this->length(); RELEASE_ASSERT(pos <= length); unsigned numCharacters = std::min(length - pos, maxLength); if (!numCharacters) return 0; if (is8Bit()) StringImpl::copyChars(buffer, characters8() + pos, numCharacters); else StringImpl::copyChars(buffer, characters16() + pos, numCharacters); return numCharacters; }
void String::remove(unsigned position, int lengthToRemove) { if (lengthToRemove <= 0) return; if (position >= length()) return; if (static_cast<unsigned>(lengthToRemove) > length() - position) lengthToRemove = length() - position; if (is8Bit()) { removeInternal(characters8(), position, lengthToRemove); return; } removeInternal(characters16(), position, lengthToRemove); }
RetainPtr<CFStringRef> StringImpl::createCFString() { // Since garbage collection isn't compatible with custom allocators, we // can't use the NoCopy variants of CFStringCreate*() when GC is enabled. if (!m_length || !isMainThread() || garbageCollectionEnabled()) { if (is8Bit()) return adoptCF(CFStringCreateWithBytes(0, reinterpret_cast<const UInt8*>(characters8()), m_length, kCFStringEncodingISOLatin1, false)); return adoptCF(CFStringCreateWithCharacters(0, reinterpret_cast<const UniChar*>(characters16()), m_length)); } CFAllocatorRef allocator = StringWrapperCFAllocator::allocator(); // Put pointer to the StringImpl in a global so the allocator can store it with the CFString. ASSERT(!StringWrapperCFAllocator::currentString); StringWrapperCFAllocator::currentString = this; CFStringRef string; if (is8Bit()) string = CFStringCreateWithBytesNoCopy(allocator, reinterpret_cast<const UInt8*>(characters8()), m_length, kCFStringEncodingISOLatin1, false, kCFAllocatorNull); else string = CFStringCreateWithCharactersNoCopy(allocator, reinterpret_cast<const UniChar*>(characters16()), m_length, kCFAllocatorNull); // CoreFoundation might not have to allocate anything, we clear currentString in case we did not execute allocate(). StringWrapperCFAllocator::currentString = 0; return adoptCF(string); }