357 lines
9.2 KiB
C++
357 lines
9.2 KiB
C++
/*
|
|
*******************************************************************************
|
|
* Copyright (C) 1997-1999, International Business Machines Corporation and *
|
|
* others. All Rights Reserved. *
|
|
*******************************************************************************
|
|
*
|
|
* File SIMTXBD.CPP
|
|
*
|
|
* Modification History:
|
|
*
|
|
* Date Name Description
|
|
* 02/18/97 aliu Converted from OpenClass. Converted offset_type
|
|
* to UTextOffset.
|
|
* 05/06/97 aliu Modified previousSafePosition to check for 0 offset. Not
|
|
* sure why this wasn't there before. (?)
|
|
* 08/11/98 helena Sync-up JDK1.2.
|
|
*****************************************************************************************
|
|
*/
|
|
|
|
// *****************************************************************************
|
|
// This file was generated from the java source file SimpleTextBoundary.java
|
|
// *****************************************************************************
|
|
|
|
#include "simtxbd.h"
|
|
#include "wdbktbl.h"
|
|
#include "unicdcm.h"
|
|
#include "schriter.h"
|
|
#ifdef _DEBUG
|
|
#include "unistrm.h"
|
|
#endif
|
|
|
|
// *****************************************************************************
|
|
// class SimpleTextBoundary
|
|
// This class is an implementation of the BreakIterator
|
|
// protocol. SimpleTextBoundary uses a state machine to compute breaks.
|
|
// There are currently several subclasses of SimpleTextBoundary that
|
|
// compute breaks for sentences, words, lines, and characters.
|
|
// *****************************************************************************
|
|
|
|
char SimpleTextBoundary::fgClassID = 0; // Value is irrelevant
|
|
const UChar SimpleTextBoundary::kEND_OF_STRING = 0xFFFF;
|
|
|
|
// Creates a simple text boundary instance with the text boundary data.
|
|
SimpleTextBoundary::SimpleTextBoundary(const TextBoundaryData* data)
|
|
: fData(data), fText(0), fPos(0)
|
|
{
|
|
fForward = fData->forward();
|
|
fBackward = fData->backward();
|
|
fMap = fData->map();
|
|
}
|
|
|
|
// -------------------------------------
|
|
|
|
SimpleTextBoundary::~SimpleTextBoundary()
|
|
{
|
|
}
|
|
|
|
// -------------------------------------
|
|
// copy constructor
|
|
|
|
SimpleTextBoundary::SimpleTextBoundary(const SimpleTextBoundary& rhs)
|
|
: fData(rhs.fData), fText(rhs.fText), fPos(rhs.fPos)
|
|
{
|
|
fForward = fData->forward();
|
|
fBackward = fData->backward();
|
|
fMap = fData->map();
|
|
}
|
|
|
|
// -------------------------------------
|
|
|
|
BreakIterator*
|
|
SimpleTextBoundary::clone() const
|
|
{
|
|
return new SimpleTextBoundary(*this);
|
|
}
|
|
|
|
// -------------------------------------
|
|
|
|
bool_t
|
|
SimpleTextBoundary::operator==(const BreakIterator& rhs) const
|
|
{
|
|
const SimpleTextBoundary* other = (const SimpleTextBoundary*)&rhs;
|
|
|
|
return (this == &rhs) ||
|
|
(rhs.getDynamicClassID() == getStaticClassID() &&
|
|
// Pointer equality on fData sufficices since these are singletons
|
|
fData == other->fData &&
|
|
fPos == other->fPos &&
|
|
((fText == other->fText) // This handles the case when both ptrs are 0
|
|
|| (fText != 0 && other->fText != 0 && *fText == *other->fText)));
|
|
}
|
|
|
|
// -------------------------------------
|
|
// Gets the target text.
|
|
|
|
CharacterIterator*
|
|
SimpleTextBoundary::createText() const
|
|
{
|
|
return fText->clone();
|
|
}
|
|
|
|
// -------------------------------------
|
|
// Sets the target text.
|
|
|
|
void
|
|
SimpleTextBoundary::setText(const UnicodeString* text)
|
|
{
|
|
delete fText;
|
|
fText = 0;
|
|
fText = new StringCharacterIterator(*text);
|
|
fPos = 0;
|
|
}
|
|
|
|
// -------------------------------------
|
|
// Sets the target text.
|
|
|
|
void
|
|
SimpleTextBoundary::adoptText(CharacterIterator* text)
|
|
{
|
|
delete fText;
|
|
fText = 0;
|
|
fText = text;
|
|
fPos = 0;
|
|
}
|
|
|
|
// -------------------------------------
|
|
// Gets the first text offset of the target text.
|
|
|
|
UTextOffset
|
|
SimpleTextBoundary::first()
|
|
{
|
|
fPos = fText->startIndex();
|
|
return fPos;
|
|
}
|
|
|
|
// -------------------------------------
|
|
// Gets the last text offset of the target text.
|
|
|
|
UTextOffset
|
|
SimpleTextBoundary::last()
|
|
{
|
|
fPos = (fText == 0) ? 0 : fText->endIndex();
|
|
return fPos;
|
|
}
|
|
|
|
// -------------------------------------
|
|
// Gets the next offset of the target text after the cursor increment.
|
|
|
|
UTextOffset
|
|
SimpleTextBoundary::next(int32_t increment)
|
|
{
|
|
UTextOffset result = current();
|
|
|
|
// If increment is negative, step backwards until the beginning
|
|
// of string is reached.
|
|
if (increment < 0) {
|
|
for (int32_t i = increment; (i < 0) && (result != DONE); ++i) {
|
|
result = previous();
|
|
}
|
|
} else {
|
|
for (int32_t i = increment; (i > 0) && (result != DONE); --i) {
|
|
result = next();
|
|
}
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
// -------------------------------------
|
|
// Gets the previous offset of the target at the cursor.
|
|
|
|
UTextOffset
|
|
SimpleTextBoundary::previous()
|
|
{
|
|
if (fPos > fText->startIndex()) { // != 0, DON'T need to check for != DONE as well
|
|
UTextOffset startBoundary = fPos;
|
|
// finds the previous safe position to backtrack to
|
|
fPos = previousSafePosition(fPos - 1);
|
|
UTextOffset prevPos = fPos;
|
|
UTextOffset nextPos = next();
|
|
// if the next position does not point to the start of a text boundary,
|
|
// finds the next start point.
|
|
while (nextPos < startBoundary && nextPos != DONE) {
|
|
prevPos = nextPos;
|
|
nextPos = next();
|
|
}
|
|
fPos = prevPos;
|
|
return fPos;
|
|
}
|
|
// already at the beginning of the target text
|
|
else {
|
|
return DONE;
|
|
}
|
|
}
|
|
|
|
// -------------------------------------
|
|
// Gets the next offset of the target at the cursor.
|
|
|
|
UTextOffset
|
|
SimpleTextBoundary::next()
|
|
{
|
|
UTextOffset result = fPos;
|
|
|
|
// Finds the next position of the end of string is not reached.
|
|
if (fPos < ((fText == 0) ? 0 : fText->endIndex())) {
|
|
fPos = nextPosition(fPos);
|
|
result = fPos;
|
|
}
|
|
else {
|
|
result = DONE;
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
// -------------------------------------
|
|
// Finds the offset of the next text boundary after the specified offset.
|
|
|
|
UTextOffset
|
|
SimpleTextBoundary::following(UTextOffset offset)
|
|
{
|
|
if (offset >= ((fText == 0) ? 0 : fText->endIndex()))
|
|
{
|
|
fPos = (fText == 0) ? 0 : fText->endIndex();
|
|
return DONE;
|
|
}
|
|
else if (offset < fText->startIndex())
|
|
{
|
|
fPos = 0;
|
|
return 0;
|
|
}
|
|
|
|
fPos = previousSafePosition(offset);
|
|
UTextOffset result;
|
|
do {
|
|
result = next();
|
|
}
|
|
while (result <= offset && result != DONE);
|
|
|
|
return result;
|
|
}
|
|
|
|
// -------------------------------------
|
|
// Finds the offset of the next text boundary before the specified offset.
|
|
|
|
UTextOffset
|
|
SimpleTextBoundary::preceding(UTextOffset offset)
|
|
{
|
|
if (offset <= fText->startIndex())
|
|
{
|
|
fPos = 0;
|
|
return DONE;
|
|
}
|
|
else if (offset > ((fText == 0) ? 0 : fText->endIndex()))
|
|
{
|
|
fPos = (fText == 0) ? 0 : fText->endIndex();
|
|
return fPos;
|
|
}
|
|
|
|
fPos = previousSafePosition(offset);
|
|
UTextOffset p = fPos;
|
|
UTextOffset last;
|
|
do {
|
|
last = p;
|
|
p = next();
|
|
}
|
|
while (p < offset && p != DONE);
|
|
|
|
fPos = last;
|
|
return last;
|
|
}
|
|
|
|
bool_t
|
|
SimpleTextBoundary::isBoundary(UTextOffset offset)
|
|
{
|
|
UTextOffset begin = fText->startIndex();
|
|
if (offset < begin || offset >= ((fText == 0) ? 0 : fText->endIndex())) {
|
|
return FALSE;
|
|
} if (offset == begin) {
|
|
return TRUE;
|
|
} else {
|
|
return following(offset - 1) == offset;
|
|
}
|
|
}
|
|
|
|
|
|
// -------------------------------------
|
|
// Returns the current text offset.
|
|
|
|
UTextOffset
|
|
SimpleTextBoundary::current() const
|
|
{
|
|
return fPos;
|
|
}
|
|
|
|
// -------------------------------------
|
|
// Finds the previous safe position; stepping backwards in the target text
|
|
// until the end state is reached.
|
|
|
|
UTextOffset
|
|
SimpleTextBoundary::previousSafePosition(UTextOffset offset)
|
|
{
|
|
UTextOffset result = fText->startIndex();
|
|
|
|
// Stepping the target text backwards to find the previous safe spot.
|
|
TextBoundaryData::Node state = fBackward->initialState();
|
|
UChar c;
|
|
|
|
if (offset == result)
|
|
++offset;
|
|
|
|
for (c = fText->setIndex(offset - 1);
|
|
c != CharacterIterator::DONE && !fBackward->isEndState(state);
|
|
c = fText->previous()) {
|
|
|
|
state = fBackward->get(state, fMap->mappedChar(c));
|
|
if (fBackward->isMarkState(state)) {
|
|
result = fText->getIndex();
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
|
|
// -------------------------------------
|
|
// Finds the next position; stepping forwards in the target text
|
|
// until the end state is reached.
|
|
|
|
UTextOffset
|
|
SimpleTextBoundary::nextPosition(UTextOffset offset)
|
|
{
|
|
UTextOffset endIndex = (fText == 0) ? 0 : fText->endIndex();
|
|
|
|
TextBoundaryData::Node state = fForward->initialState();
|
|
UTextOffset p = offset;
|
|
UChar c;
|
|
|
|
for (c = fText->setIndex(offset);
|
|
c != CharacterIterator::DONE && !fForward->isEndState(state);
|
|
c = fText->next()) {
|
|
state = fForward->get(state, fMap->mappedChar(c));
|
|
if (fForward->isMarkState(state)) {
|
|
endIndex = fText->getIndex();
|
|
}
|
|
}
|
|
if (fForward->isEndState(state))
|
|
return endIndex;
|
|
else {
|
|
state = fForward->get(state, fMap->mappedChar(kEND_OF_STRING));
|
|
if (fForward->isMarkState(state))
|
|
return ((fText == 0) ? 0 : fText->endIndex());
|
|
else
|
|
return endIndex;
|
|
}
|
|
}
|
|
|
|
//eof
|