bool Board_Move_Dataset_record::next() {
if (isEndOfData()) return false;
m_currentBoard.moveNext();
if (m_currentBoard.isLast()) {
return changeToNextRecord();
}
return true;
}
Board_Move_Data Board_Move_Dataset_record::get() const {
if (isEndOfData()) {
return Board_Move_Data();
}
const shared_ptr<Board> board = m_currentBoard.getCurrentBoardPtr();
//cerr << "board history size = " << board->m_changeHistory.size() << endl;
Record::Move move(m_currentBoard.getNextMove());
Point m;
if (move.x == PASS || move.y == PASS) {
m = PASS;
} else {
m = board->xyToPoint(move.x, move.y);
}
Color turn = m_currentBoard.getNextTurn();
return Board_Move_Data(board, m, turn, POINT_NULL);
}
bool isValidLength(string const & data, Length * result)
{
// This is a trimmed down version of isValidGlueLength.
// The parser may seem overkill for lengths without
// glue, but since we already have it, using it is
// easier than writing something from scratch.
if (data.empty())
return true;
string buffer = data;
int pattern_index = 0;
char pattern[3];
// To make isValidLength recognize negative values
// this little hack is needed:
int val_sign = 1; // positive as default
switch (buffer[0]) {
case '-':
lyx_advance(buffer, 1);
val_sign = -1;
break;
case '+':
lyx_advance(buffer, 1);
// fall through
default:
// no action
break;
}
// end of hack
// used to return numeric values in parsing vspace
double number[4] = { 0, 0, 0, 0 };
// used to return unit types in parsing vspace
Length::UNIT unit[4] = {Length::UNIT_NONE, Length::UNIT_NONE,
Length::UNIT_NONE, Length::UNIT_NONE};
int number_index = 1; // entries at index 0 are sentinels
int unit_index = 1; // entries at index 0 are sentinels
// construct "pattern" from "data"
while (!isEndOfData(buffer)) {
if (pattern_index > 2)
return false;
pattern[pattern_index] = nextToken(buffer, number,
number_index, unit, unit_index);
if (pattern[pattern_index] == 'E')
return false;
++pattern_index;
}
pattern[pattern_index] = '\0';
// only the most basic pattern is accepted here
if (strcmp(pattern, "nu") != 0)
return false;
// It _was_ a correct length string.
// Store away the values we found.
if (result) {
result->val_ = number[1] * val_sign;
result->unit_ = unit[1];
}
return true;
}
bool isValidGlueLength(string const & data, GlueLength * result)
{
// This parser is table-driven. First, it constructs a "pattern"
// that describes the sequence of tokens in "data". For example,
// "n-nu" means: number, minus sign, number, unit. As we go along,
// numbers and units are stored into static arrays. Then, "pattern"
// is searched in the "table". If it is found, the associated
// table entries tell us which number and unit should go where
// in the Length structure. Example: if "data" has the "pattern"
// "nu+nu-nu", the associated table entries are "2, 3, 2, 3".
// That means, "plus_val" is the second number that was seen
// in the input, "minus_val" is the third number, and "plus_uni"
// and "minus_uni" are the second and third units, respectively.
// ("val" and "uni" are always the first items seen in "data".)
// This is the most elegant solution I could find -- a straight-
// forward approach leads to very long, tedious code that would be
// much harder to understand and maintain. (AS)
if (data.empty())
return true;
string buffer = ltrim(data);
// To make isValidGlueLength recognize negative values as
// the first number this little hack is needed:
int val_sign = 1; // positive as default
switch (buffer[0]) {
case '-':
lyx_advance(buffer, 1);
val_sign = -1;
break;
case '+':
lyx_advance(buffer, 1);
break;
default:
break;
}
// end of hack
// used to return numeric values in parsing vspace
double number[4] = { 0, 0, 0, 0 };
// used to return unit types in parsing vspace
Length::UNIT unit[4] = {Length::UNIT_NONE, Length::UNIT_NONE,
Length::UNIT_NONE, Length::UNIT_NONE};
int number_index = 1; // entries at index 0 are sentinels
int unit_index = 1; // entries at index 0 are sentinels
// construct "pattern" from "data"
size_t const pattern_max_size = 20;
string pattern;
while (!isEndOfData(buffer)) {
if (pattern.size() > pattern_max_size)
return false;
char const c = nextToken(buffer, number, number_index, unit,
unit_index);
if (c == 'E')
return false;
pattern.push_back(c);
}
// search "pattern" in "table"
size_t table_index = 0;
while (pattern != table[table_index].pattern) {
++table_index;
if (!*table[table_index].pattern)
return false;
}
// Get the values from the appropriate places. If an index
// is zero, the corresponding array value is zero or UNIT_NONE,
// so we needn't check this.
if (result) {
result->len_.value (number[1] * val_sign);
result->len_.unit (unit[1]);
result->plus_.value (number[table[table_index].plus_val_index]);
result->plus_.unit (unit [table[table_index].plus_uni_index]);
result->minus_.value(number[table[table_index].minus_val_index]);
result->minus_.unit (unit [table[table_index].minus_uni_index]);
}
return true;
}