The Tor Browser: comparison gfx/thebes/gfxSkipChars.h

--1:000000000000
+:0b68316b52ed
+/* -*- Mode: C++; tab-width: 20; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+* 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 GFX_SKIP_CHARS_H
+#define GFX_SKIP_CHARS_H
+#include "nsTArray.h"
+/*
+* gfxSkipChars is a data structure representing a list of characters that
+* have been skipped. The initial string is called the "original string"
+* and after skipping some characters, the result is called the "skipped string".
+* gfxSkipChars provides efficient ways to translate between offsets in the
+* original string and the skipped string. It is used by textrun code to keep
+* track of offsets before and after text transformations such as whitespace
+* compression and control code deletion.
+*/
+/**
+* The gfxSkipChars is represented as a sorted array of skipped ranges.
+*
+* A freshly-created gfxSkipChars means "all chars kept".
+*/
+class gfxSkipChars
+{
+private:
+class SkippedRange
+{
+public:
+SkippedRange(uint32_t aOffset, uint32_t aLength, uint32_t aDelta)
+: mOffset(aOffset), mLength(aLength), mDelta(aDelta)
+{ }
+uint32_t Start() const
+{
+return mOffset;
+}
+uint32_t End() const
+{
+return mOffset + mLength;
+}
+uint32_t Length() const
+{
+return mLength;
+}
+uint32_t SkippedOffset() const
+{
+return mOffset - mDelta;
+}
+uint32_t Delta() const
+{
+return mDelta;
+}
+uint32_t NextDelta() const
+{
+return mDelta + mLength;
+}
+void Extend(uint32_t aChars)
+{
+mLength += aChars;
+}
+private:
+uint32_t mOffset; // original-string offset at which we want to skip
+uint32_t mLength; // number of skipped chars at this offset
+uint32_t mDelta;  // sum of lengths of preceding skipped-ranges
+};
+public:
+gfxSkipChars()
+: mCharCount(0)
+{ }
+void SkipChars(uint32_t aChars)
+{
+NS_ASSERTION(mCharCount + aChars > mCharCount,
+"Character count overflow");
+uint32_t rangeCount = mRanges.Length();
+uint32_t delta = 0;
+if (rangeCount > 0) {
+SkippedRange& lastRange = mRanges[rangeCount - 1];
+if (lastRange.End() == mCharCount) {
+lastRange.Extend(aChars);
+mCharCount += aChars;
+return;
+}
+delta = lastRange.NextDelta();
+}
+mRanges.AppendElement(SkippedRange(mCharCount, aChars, delta));
+mCharCount += aChars;
+}
+void KeepChars(uint32_t aChars)
+{
+NS_ASSERTION(mCharCount + aChars > mCharCount,
+"Character count overflow");
+mCharCount += aChars;
+}
+void SkipChar()
+{
+SkipChars(1);
+}
+void KeepChar()
+{
+KeepChars(1);
+}
+void TakeFrom(gfxSkipChars* aSkipChars)
+{
+mRanges.SwapElements(aSkipChars->mRanges);
+mCharCount = aSkipChars->mCharCount;
+aSkipChars->mCharCount = 0;
+}
+int32_t GetOriginalCharCount() const
+{
+return mCharCount;
+}
+const SkippedRange& LastRange() const
+{
+// this is only valid if mRanges is non-empty; no assertion here
+// because nsTArray will already assert if we abuse it
+return mRanges[mRanges.Length() - 1];
+}
+friend class gfxSkipCharsIterator;
+private:
+nsTArray<SkippedRange> mRanges;
+uint32_t               mCharCount;
+};
+/**
+* A gfxSkipCharsIterator represents a position in the original string. It lets you
+* map efficiently to and from positions in the string after skipped characters
+* have been removed. You can also specify an offset that is added to all
+* incoming original string offsets and subtracted from all outgoing original
+* string offsets --- useful when the gfxSkipChars corresponds to something
+* offset from the original DOM coordinates, which it often does for gfxTextRuns.
+*
+* The current positions (in both the original and skipped strings) are
+* always constrained to be >= 0 and <= the string length. When the position
+* is equal to the string length, it is at the end of the string. The current
+* positions do not include any aOriginalStringToSkipCharsOffset.
+*
+* When the position in the original string corresponds to a skipped character,
+* the skipped-characters offset is the offset of the next unskipped character,
+* or the skipped-characters string length if there is no next unskipped character.
+*/
+class gfxSkipCharsIterator
+{
+public:
+/**
+* @param aOriginalStringToSkipCharsOffset add this to all incoming and
+* outgoing original string offsets
+*/
+gfxSkipCharsIterator(const gfxSkipChars& aSkipChars,
+int32_t aOriginalStringToSkipCharsOffset,
+int32_t aOriginalStringOffset)
+: mSkipChars(&aSkipChars),
+mOriginalStringOffset(0),
+mSkippedStringOffset(0),
+mCurrentRangeIndex(-1),
+mOriginalStringToSkipCharsOffset(aOriginalStringToSkipCharsOffset)
+{
+SetOriginalOffset(aOriginalStringOffset);
+}
+gfxSkipCharsIterator(const gfxSkipChars& aSkipChars,
+int32_t aOriginalStringToSkipCharsOffset = 0)
+: mSkipChars(&aSkipChars),
+mOriginalStringOffset(0),
+mSkippedStringOffset(0),
+mCurrentRangeIndex(-1),
+mOriginalStringToSkipCharsOffset(aOriginalStringToSkipCharsOffset)
+{ }
+gfxSkipCharsIterator(const gfxSkipCharsIterator& aIterator)
+: mSkipChars(aIterator.mSkipChars),
+mOriginalStringOffset(aIterator.mOriginalStringOffset),
+mSkippedStringOffset(aIterator.mSkippedStringOffset),
+mCurrentRangeIndex(aIterator.mCurrentRangeIndex),
+mOriginalStringToSkipCharsOffset(aIterator.mOriginalStringToSkipCharsOffset)
+{ }
+/**
+* The empty constructor creates an object that is useless until it is assigned.
+*/
+gfxSkipCharsIterator()
+: mSkipChars(nullptr)
+{ }
+/**
+* Return true if this iterator is properly initialized and usable.
+*/
+bool IsInitialized()
+{
+return mSkipChars != nullptr;
+}
+/**
+* Set the iterator to aOriginalStringOffset in the original string.
+* This can efficiently move forward or backward from the current position.
+* aOriginalStringOffset is clamped to [0,originalStringLength].
+*/
+void SetOriginalOffset(int32_t aOriginalStringOffset);
+/**
+* Set the iterator to aSkippedStringOffset in the skipped string.
+* This can efficiently move forward or backward from the current position.
+* aSkippedStringOffset is clamped to [0,skippedStringLength].
+*/
+void SetSkippedOffset(uint32_t aSkippedStringOffset);
+uint32_t ConvertOriginalToSkipped(int32_t aOriginalStringOffset)
+{
+SetOriginalOffset(aOriginalStringOffset);
+return GetSkippedOffset();
+}
+uint32_t ConvertSkippedToOriginal(int32_t aSkippedStringOffset)
+{
+SetSkippedOffset(aSkippedStringOffset);
+return GetOriginalOffset();
+}
+/**
+* Test if the character at the current position in the original string
+* is skipped or not. If aRunLength is non-null, then *aRunLength is set
+* to a number of characters all of which are either skipped or not, starting
+* at this character. When the current position is at the end of the original
+* string, we return true and *aRunLength is set to zero.
+*/
+bool IsOriginalCharSkipped(int32_t* aRunLength = nullptr) const;
+void AdvanceOriginal(int32_t aDelta)
+{
+SetOriginalOffset(GetOriginalOffset() + aDelta);
+}
+void AdvanceSkipped(int32_t aDelta)
+{
+SetSkippedOffset(GetSkippedOffset() + aDelta);
+}
+/**
+* @return the offset within the original string
+*/
+int32_t GetOriginalOffset() const
+{
+return mOriginalStringOffset - mOriginalStringToSkipCharsOffset;
+}
+/**
+* @return the offset within the skipped string corresponding to the
+* current position in the original string. If the current position
+* in the original string is a character that is skipped, then we return
+* the position corresponding to the first non-skipped character in the
+* original string after the current position, or the length of the skipped
+* string if there is no such character.
+*/
+uint32_t GetSkippedOffset() const
+{
+return mSkippedStringOffset;
+}
+int32_t GetOriginalEnd() const
+{
+return mSkipChars->GetOriginalCharCount() -
+mOriginalStringToSkipCharsOffset;
+}
+private:
+const gfxSkipChars* mSkipChars;
+// Current position
+int32_t mOriginalStringOffset;
+uint32_t mSkippedStringOffset;
+// Index of the last skippedRange that precedes or contains the current
+// position in the original string.
+// If index == -1 then we are before the first skipped char.
+int32_t mCurrentRangeIndex;
+// This offset is added to map from "skipped+unskipped characters in
+// the original DOM string" character space to "skipped+unskipped
+// characters in the textrun's gfxSkipChars" character space
+int32_t mOriginalStringToSkipCharsOffset;
+};
+#endif /*GFX_SKIP_CHARS_H*/

The Tor Browser / file comparison

comparison: gfx/thebes/gfxSkipChars.h

gfx/thebes/gfxSkipChars.h