C++ Square::Next方法代码示例

void UnLoadSolutionRebus(Puzzle * puz)
{
    for (Square * square = puz->GetGrid().First();
         square != NULL;
         square = square->Next())
    {
        square->SetSolutionRebus(string_t(1, char_t(square->GetPlainSolution())));
    }
}

// Rollback changes
void UnLoadCHKD(Puzzle * puz)
{
    for (Square * square = puz->GetGrid().First();
         square != NULL;
         square = square->Next())
    {
        square->RemoveFlag(FLAG_CORRECT);
    }
}

// Rollback changes
void UnLoadGEXT(Puzzle * puz)
{
    for (Square * square = puz->GetGrid().First();
         square != NULL;
         square = square->Next())
    {
        square->SetFlag(FLAG_CLEAR);
    }
}

bool LoadGEXT(Puzzle * puz, const std::string & data)
{
    std::istringstream stream(data);
    istream_wrapper f(stream);

    std::string::const_iterator it = data.begin();
    for (Square * square = puz->GetGrid().First();
         square != NULL;
         square = square->Next())
    {
        square->SetFlag(f.ReadChar());
    }
    if (! f.CheckEof())
        return false;
    return true;
}

//------------------------------------------------------------------------------
// RUSR (user rebus grid)
//------------------------------------------------------------------------------
bool LoadRUSR(Puzzle * puz, const std::string & data)
{
    // RUSR is a series of strings (each nul-terminated) that represent any
    // user grid rebus entries.  If the rebus is a symbol, it is enclosed
    // in '[' ']'.

    std::istringstream stream(data);
    istream_wrapper f(stream);

    for (Square * square = puz->GetGrid().First();
         square != NULL;
         square = square->Next())
    {
        std::string str = f.ReadString();

        if (str.empty())
            continue;

        square->SetText(decode_puz(str));
    }
    if (! f.CheckEof())
        return false;
    return true;
}

bool LoadSolutionRebus(Puzzle * puz,
                       const std::string & table,
                       const std::string & grid)
{
    // NB: In the grid rebus section (GRBS), the index is 1 greater than the
    // index in the rebus table section (RTBL).

    if (grid.size() !=  puz->GetGrid().GetWidth() * puz->GetGrid().GetHeight())
        return false;

    // Read the rebus table (RTBL)
    // Format: index ':' string ';'
    //   - Index is a number, padded to two digits with a space if needed.
    std::map<unsigned char, std::string> rebusTable;

    std::istringstream tstream(table);
    istream_wrapper table_stream(tstream);

    for (;;)
    {
        std::string key;

        // Read the index
        try {
            key = table_stream.ReadString(':');
        }
        catch(std::ios::failure &) {
            break;
        }

        int index = atoi(key.c_str());
        if (index == 0 && key != " 0")
            return false;

        // The index value in the rebus-table section is 1 less than the
        // index in the grid-rebus, so we need add 1 here.
        ++index;

        std::string value = table_stream.ReadString(';');

        rebusTable[static_cast<unsigned char>(index)] = value;
    }
    if (! table_stream.CheckEof())
        return false;


    // Set the grid rebus solution
    std::istringstream gstream(grid);
    istream_wrapper grid_stream(gstream);

    for (Square * square = puz->GetGrid().First();
         square != NULL;
         square = square->Next())
    {
        const unsigned char index = grid_stream.ReadChar();
        if (index > 0)
        {
            // Look for this index in the rebus table
            std::map<unsigned char, std::string>::const_iterator it;
            it = rebusTable.find(index);
            if (it == rebusTable.end())
                return false;

            // Don't overwrite the plain solution
            square->SetSolutionRebus(decode_puz(it->second));
        }
    }
    if (! grid_stream.CheckEof())
        return false;
    return true;
}

void LoadPuz(Puzzle * puz, const std::string & filename, void * /* dummy */)
{
    std::ifstream stream(filename.c_str(), std::ios::in | std::ios::binary);
    if (stream.fail())
        throw FileError(filename);
    istream_wrapper f(stream);

    const unsigned short c_primary = f.ReadShort();
    if (strcmp(f.ReadString(12).c_str(), "ACROSS&DOWN") != 0)
        throw FileTypeError("puz");

    const unsigned short c_cib = f.ReadShort();
    unsigned char c_masked[8];
    f.ReadCharArray(c_masked, 8);

    // Version is "[major].[minor]\0"
    // We can read puzzles of 1.[anything]
    std::string versionstr = f.ReadString(4);
    if (versionstr[0] != '1' || ! isdigit(versionstr[2]))
        throw LoadError("Unknown puz version.");

    const unsigned short version = 10 + versionstr[2] - 0x30;

    f.Skip(2); // 1 unknown short
    const unsigned short c_grid = f.ReadShort();
    f.Skip(2 * 6); // 6 noise shorts

    const unsigned char width  = f.ReadChar();
    const unsigned char height = f.ReadChar();

    const unsigned short num_clues = f.ReadShort();
    const unsigned short grid_type = f.ReadShort();
    const unsigned short grid_flag = f.ReadShort();

    puz->GetGrid().SetCksum(c_grid);
    puz->GetGrid().SetType(grid_type);
    puz->GetGrid().SetFlag(grid_flag);
    puz->GetGrid().SetSize(width, height);

    // Read user text and solution
    std::string solution = f.ReadString(width * height);
    std::string text     = f.ReadString(width * height);

    // Set the grid's solution and text
    std::string::iterator sol_it  = solution.begin();
    std::string::iterator text_it = text.begin();
    for (Square * square = puz->GetGrid().First();
         square != NULL;
         square = square->Next())
    {
        // Solution
        if (*sol_it == '.' || *sol_it == ':' && puz->IsDiagramless())
            square->SetSolution(puz::Square::Black);
        else if (*sol_it == '-')
            square->SetSolution(puz::Square::Blank);
        else
            square->SetSolution(decode_puz(std::string(1, *sol_it)));
        ++sol_it;

        // Text
        if (square->IsBlack() && ! puz->IsDiagramless())
            square->SetText(puz::Square::Black);
        else if (*text_it == '-' || *text_it == 0)
            square->SetText(puz::Square::Blank);
        else if (puz->IsDiagramless() && (*text_it == '.' || *text_it == ':'))
        {
            // Black squares in a diagramless puzzle.
            if (*text_it == '.')
                square->SetText(puz::Square::Black);
            else if (*text_it == ':')
                square->SetText(puz::Square::Blank);
        }
        else
        {
            square->SetText(decode_puz(std::string(1, *text_it)));
            if (islower(*text_it))
                square->AddFlag(FLAG_PENCIL);
        }
        ++text_it;
    }
    assert(sol_it == solution.end() && text_it == text.end());
    puz->NumberGrid();

    // General puzzle info
    puz->SetTitle(decode_puz(f.ReadString()));
    puz->SetAuthor(decode_puz(f.ReadString()));
    puz->SetCopyright(decode_puz(f.ReadString()));

    // Clues
    std::vector<string_t> clues;
    clues.reserve(num_clues);
    // Save unaltered clues for the checksums
    std::vector<std::string> cksum_clues;
    cksum_clues.reserve(num_clues);
    for (size_t i = 0; i < num_clues; ++i)
    {
        cksum_clues.push_back(f.ReadString());
        clues.push_back(escape_xml(decode_puz(cksum_clues.back())));
    }

//.........这里部分代码省略.........

bool
Scrambler::ScrambleSolution(unsigned short key_int)
{
    bool ok = m_grid.GetWidth() > 0 && m_grid.GetHeight() > 0;
    ok = ok && (m_grid.m_flag & FLAG_NO_SOLUTION) == 0;

    assert(m_grid.First() != NULL);

    if (! ok)
        return false;

    if (key_int == 0)
        key_int = MakeKey();

    assert(1000 <= key_int && key_int <= 9999);

    // Read the key into an array of single digits
    unsigned char key[4];
    key[0] = int(key_int / 1000) % 10;
    key[1] = int(key_int / 100)  % 10;
    key[2] = int(key_int / 10)   % 10;
    key[3] = int(key_int / 1)    % 10;

    std::string solution = GetSolutionDown();

    unsigned short cksum = Checksummer::cksum_region(solution, 0);
    if (cksum == 0)
        return false;

    size_t length = solution.length();

    // Don't scramble really small puzzles
    if(length < 12)
        return 0;

    // Do the scrambling
    for (int i = 0; i < 4; ++i)
    {
        std::string scramble_part;
        for (size_t j = 0; j < length; ++j)
        {
            char letter = solution[j] + key[j % 4];

            // Make sure the letter is capital
            if (letter > 90)
                letter -= 26;

            // Range for capital letters
            assert(isupper(letter));

            scramble_part.push_back(letter);
        }
        assert(scramble_part.length() == length);

        scramble_part = ShiftString(scramble_part, key[i]);
        assert(scramble_part.length() == length);

        scramble_part = ScrambleString(scramble_part);
        assert(scramble_part.length() == length);

        solution = scramble_part;
    }


    // Save the scrambled solution to the puzzle file
    std::string::iterator it = solution.begin();
    for (Square * square = m_grid.First();
         square != NULL;
         square = square->Next(DOWN))
    {
        if (square->IsBlack())
            continue;

        // Make sure we preserve any rebus in the solution
        if (! square->HasSolutionRebus())
            square->SetSolution(decode_puz(std::string(1, *it)));
        else
            square->SetPlainSolution(*it);
        ++it;
    }
    assert(it == solution.end());

    m_grid.m_flag |= FLAG_SCRAMBLED;
    m_grid.m_cksum = cksum;
    m_grid.m_key = key_int;

    return true;
}