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);
  }
Пример #3
0
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;
}
Пример #4
0
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;
}