gecko-dev/dom/bindings/FakeString.h

166 строки
5.1 KiB
C++

/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* vim: set ts=8 sts=2 et sw=2 tw=80: */
/* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this file,
* You can obtain one at http://mozilla.org/MPL/2.0/. */
#ifndef mozilla_dom_FakeString_h__
#define mozilla_dom_FakeString_h__
#include "nsString.h"
#include "nsStringBuffer.h"
#include "mozilla/RefPtr.h"
namespace mozilla {
namespace dom {
namespace binding_detail {
// A struct that has the same layout as an nsString but much faster
// constructor and destructor behavior. FakeString uses inline storage
// for small strings and a nsStringBuffer for longer strings.
struct FakeString {
FakeString() :
mDataFlags(nsString::DataFlags::TERMINATED),
mClassFlags(nsString::ClassFlags(0))
{
}
~FakeString() {
if (mDataFlags & nsString::DataFlags::SHARED) {
nsStringBuffer::FromData(mData)->Release();
}
}
void Rebind(const nsString::char_type* aData, nsString::size_type aLength) {
MOZ_ASSERT(mDataFlags == nsString::DataFlags::TERMINATED);
mData = const_cast<nsString::char_type*>(aData);
mLength = aLength;
}
// Share aString's string buffer, if it has one; otherwise, make this string
// depend upon aString's data. aString should outlive this instance of
// FakeString.
void ShareOrDependUpon(const nsAString& aString) {
RefPtr<nsStringBuffer> sharedBuffer = nsStringBuffer::FromString(aString);
if (!sharedBuffer) {
Rebind(aString.Data(), aString.Length());
} else {
AssignFromStringBuffer(sharedBuffer.forget());
mLength = aString.Length();
}
}
void Truncate() {
MOZ_ASSERT(mDataFlags == nsString::DataFlags::TERMINATED);
mData = nsString::char_traits::sEmptyBuffer;
mLength = 0;
}
void SetIsVoid(bool aValue) {
MOZ_ASSERT(aValue,
"We don't support SetIsVoid(false) on FakeString!");
Truncate();
mDataFlags |= nsString::DataFlags::VOIDED;
}
const nsString::char_type* Data() const
{
return mData;
}
nsString::char_type* BeginWriting()
{
return mData;
}
nsString::size_type Length() const
{
return mLength;
}
// Reserve space to write aLength chars, not including null-terminator.
bool SetLength(nsString::size_type aLength, mozilla::fallible_t const&) {
// Use mInlineStorage for small strings.
if (aLength < sInlineCapacity) {
SetData(mInlineStorage);
} else {
RefPtr<nsStringBuffer> buf = nsStringBuffer::Alloc((aLength + 1) * sizeof(nsString::char_type));
if (MOZ_UNLIKELY(!buf)) {
return false;
}
AssignFromStringBuffer(buf.forget());
}
mLength = aLength;
mData[mLength] = char16_t(0);
return true;
}
// If this ever changes, change the corresponding code in the
// Optional<nsAString> specialization as well.
const nsAString* ToAStringPtr() const {
return reinterpret_cast<const nsString*>(this);
}
operator const nsAString& () const {
return *reinterpret_cast<const nsString*>(this);
}
private:
nsAString* ToAStringPtr() {
return reinterpret_cast<nsString*>(this);
}
nsString::char_type* mData;
nsString::size_type mLength;
nsString::DataFlags mDataFlags;
nsString::ClassFlags mClassFlags;
static const size_t sInlineCapacity = 64;
nsString::char_type mInlineStorage[sInlineCapacity];
FakeString(const FakeString& other) = delete;
void operator=(const FakeString& other) = delete;
void SetData(nsString::char_type* aData) {
MOZ_ASSERT(mDataFlags == nsString::DataFlags::TERMINATED);
mData = const_cast<nsString::char_type*>(aData);
}
void AssignFromStringBuffer(already_AddRefed<nsStringBuffer> aBuffer) {
SetData(static_cast<nsString::char_type*>(aBuffer.take()->Data()));
mDataFlags = nsString::DataFlags::SHARED | nsString::DataFlags::TERMINATED;
}
friend class NonNull<nsAString>;
// A class to use for our static asserts to ensure our object layout
// matches that of nsString.
class StringAsserter;
friend class StringAsserter;
class StringAsserter : public nsString {
public:
static void StaticAsserts() {
static_assert(offsetof(FakeString, mInlineStorage) ==
sizeof(nsString),
"FakeString should include all nsString members");
static_assert(offsetof(FakeString, mData) ==
offsetof(StringAsserter, mData),
"Offset of mData should match");
static_assert(offsetof(FakeString, mLength) ==
offsetof(StringAsserter, mLength),
"Offset of mLength should match");
static_assert(offsetof(FakeString, mDataFlags) ==
offsetof(StringAsserter, mDataFlags),
"Offset of mDataFlags should match");
static_assert(offsetof(FakeString, mClassFlags) ==
offsetof(StringAsserter, mClassFlags),
"Offset of mClassFlags should match");
}
};
};
} // namespace binding_detail
} // namespace dom
} // namespace mozilla
#endif /* mozilla_dom_FakeString_h__ */