C++ AbstractCommand类代码示例

void GamePlayScene::loadGameState(const std::vector<char> *data) {
	union change {
		int i;
		unsigned char buf[4];
	} itoc;
	itoc.buf[0] = data->at(0);
	itoc.buf[1] = data->at(1);
	itoc.buf[2] = data->at(2);
	itoc.buf[3] = data->at(3);
	loadPuzzle(itoc.i);
	m_sudoku->loadGameFromBuffer(data);

	AbstractCommand *cmd;
	int pos = SUDOKU_SIZE * SUDOKU_SIZE * 3 + 4;

	while (pos < data->size()) {
		cmd = AbstractCommand::loadFromBuffer(this, data, pos);
		m_logStack.push_back(cmd);
		if (cmd->isPuzzleCmd()) {
			m_undoStack.push_back(cmd->clone());
		}
		pos += cmd->getCommandBufSize();
	}

	m_puzzleLayer->resetValues();
	m_inputLayer->setUndoButton(hasSomethingToUndo());
	m_inputLayer->setNumberCompleted();
}

void BattleInput::receiveData(QByteArray inf)
{
    if (inf.isEmpty()) {
        if (paused()) {
            delayedCommands.push_back(inf);
            return;
        }

        /* An empty array means raw Command */
        if (commands.size() > 0) {
            AbstractCommand *command = *commands.begin();
            commands.pop_front();
            command->apply();
            delete command;
            return;
        }
    }

    if (paused() && inf[0] != char(BC::BattleChat) && inf[0] != char(BC::SpectatorChat) && inf[0] != char(BC::ClockStart)
            && inf[0] != char(BC::ClockStop)
            && inf[0] != char(BC::Spectating)) {
        delayedCommands.push_back(inf);
        return;
    }

    DataStream in (&inf, QIODevice::ReadOnly);

    uchar command;
    qint8 player;

    in >> command >> player;

    dealWithCommandInfo(in, command, player);
}

AbstractCommand* Terminal::getCommandByName(char* commandName)
{
	for(uint8_t q = 0 ; q < commands->getSize() ; q ++)
	{
		AbstractCommand* command = commands->get(q);
		if(strcmp_P(commandName, (char*)command->getName()) == 0)
		{
			return command;
		}
	}

	return 0;
}

void Terminal::processHelp()
{
	if(commands->getSize() == 0)
	{
		serial->println(F("No commands available."));
		return;
	}

	for(uint8_t q = 0 ; q < commands->getSize() ; q ++)
	{
		AbstractCommand* command = commands->get(q);
		serial->println(command->getName());
	}
}

AbstractCommand *CommandFactory::parseCommand(QString const &command)
{
	QString const normalizedCommand = command.toLower().trimmed();
	QStringList const parts = normalizedCommand.split(" ", QString::SkipEmptyParts);
	if (parts.isEmpty()) {
		return 0;
	}
	AbstractCommand *result = parseCommand(parts);
	if (result) {
		result->setParent(this);
	} else {
		qDebug() << "Error while parsing command" << command;
	}
	return result;
}

void RegularBattleScene::unpause()
{
    pauseCount -= 1;

    if (pauseCount == 0 && !unpausing) {
        unpausing = true;
        while (commands.size() > 0) {
            AbstractCommand *command = *commands.begin();
            commands.pop_front();
            command->apply();
            delete command;
        }
        unpausing = false;
    }

    baseClass::unpause();
}

void Connection::receiveCommand()
{
    QByteArray arr = m_connection->readAll();
    debugOutput(1, QString::fromLatin1("Command received: ") + (arr));
    QList<CommandInfo> commands = availableCommands();
    for(QList<CommandInfo>::iterator it = commands.begin(); it != commands.end(); ++it) {
        if (it->commandName == QString::fromLatin1(arr)) {
            debugOutput(1, "Found command in list");
            disconnect(m_connection, SIGNAL(readyRead()), this, SLOT(receiveCommand()));
            AbstractCommand* command = (*it).commandFunc();
            command->setSocket(m_connection);
            m_command = command;
            return;
        }
    }
    debugOutput(2, QString::fromLatin1("Unknown command received: ") + (arr));
}

AbstractCommand * Pilot::BuildOne(DataType data, CommandType command, const std::string & commandName){
	// instanciate data
	AbstractData *    d = DataFactory::Create(data);
	if ( !d ){
		Logger::Instance() << "Error data not built";
		return NULL;
	}
	// instanciate Command
	AbstractCommand * c = CommandFactory::Create(command);
	if ( !c ){
		Logger::Instance() << "Error command not built";
		return NULL;
	}
	// link data with command and delegate ownership
	c->SetData(d);
	// append to container (take ownership, will be deleted automatically)
    _containerContainer.Set(commandName,c);	
	return c;
}

/*
* Return the index number of occurrence of this command. If doesn't exists return NULL;
* The first command has number 0.
*/
AbstractCommand* SyncMLProcessor::getCommand(SyncBody* syncBody, const char*commandName, int index) {

    int iterator = 0, found = 0;
    ArrayList* list     = syncBody->getCommands();
    AbstractCommand* a  = NULL;
    const char* name = NULL;
    do {
        a = (AbstractCommand*)getArrayElement(list, iterator);
        if (a) {
            name = a->getName();    // is returned the pointer to the element not a new element
            if (name && strcmp(name, commandName) == 0) {
                if (found == index)
                    break;
                else
                    found++;
            }
        }
        ++iterator;
    } while(a);

    return a;
}

void BattleScene::useCommand()
{
    if (commands.size() > 0) {
        AbstractCommand *command = *commands.begin();

        int val = command->val();

        if (!onPeek(val)) {
            return;
        }

        commands.pop_front();
        command->apply();
        delete command;

        if (replayCount > 0 && misReplayingCommands) {
            replayCount --;

            if (replayCount == 0) {
                misReplayingCommands = false;
            }
        }
    }
}

void Service::invokeCommand (const QString& cmd)
{
    qDebug() << "[DesktopControl::Service::invokeCommand()] Heard " << cmd << "from the user.";
    AbstractCategory* glbl = AbstractCategory::global();
    CommandList commands = glbl->matchAllCommands (cmd);

    if (!commands.isEmpty()) {
        if (commands.count() == 1) {
            AbstractCommand* onlyCommand = commands.first();
            qDebug() << "[DesktopControl::Service::invokeCommand()] Only matched a command " << onlyCommand->id() << "matched with statements" << onlyCommand->statements();
            emit commandFound (cmd, onlyCommand);
            onlyCommand->invoke (cmd);
            return;
        }
        else {
            emit multipleCommandsFound (cmd, commands);

            Q_FOREACH (AbstractCommand * command, commands) {
                qDebug() << "[DesktopControl::Service::invokeCommand()] Command " << command->id() << "matched with statements" << command->statements();
            }
        }

    }
    else {

    void testExecute(){
        Sequence sequence( "foo", 1, 4, 4, 500000 );
        Track track( "name", "singer" );
        track.events()->clear();
        Event singer( 0, EventType::SINGER );
        track.events()->add( singer, 1 );
        Event note( 1920, EventType::NOTE );
        note.note = 60;
        track.events()->add( note, 2 );
        *sequence.track(0) = track;

        Event editedNote = note;
        editedNote.note = 61;
        EditEventCommand command( 0, 2, editedNote );
        AbstractCommand *inverseCommand = command.execute( &sequence );

        CPPUNIT_ASSERT_EQUAL(61, sequence.track(0)->events()->findFromId(2)->note);

        AbstractCommand *garbage = inverseCommand->execute( &sequence );
        CPPUNIT_ASSERT_EQUAL(60, sequence.track(0)->events()->findFromId(2)->note);

        delete inverseCommand;
        delete garbage;
    }

void Terminal::loop() {
	performBackgroundCommands();

	// check for incoming commands
	if(!readString())
	{
		return;
	}

	char* command = commandParams.getParam(0);
	if(strcmp_P(command, (char*)F("break")) == 0)
	{
		cancelBackgroundCommands();

		commandParams.reset();
		printTerminalReadyIfNeeded();

		return;
	}

	if(areBackgroundCommands())
	{
		commandParams.reset();
		serial->println(F("terminal busy"));

		return;
	}

	if(strcmp_P(command, (char*)F("")) == 0)
	{
		commandParams.reset();
		printTerminalReadyIfNeeded();
		return;
	}

	if(strcmp_P(command, (char*)F("help")) == 0)
	{
		processHelp();

		commandParams.reset();
		printTerminalReadyIfNeeded();
		return;
	}

	AbstractCommand* commandToExecute = getCommandByName(command);
	if(commandToExecute != 0)
	{
		commandToExecute->process(&commandParams, this->serial);
		commandParams.reset();

		if(commandToExecute->isBackground())
		{
			this->backgroundCommand = commandToExecute;
		}
		else
		{
			printTerminalReadyIfNeeded();
		}

		return;
	}

	serial->print(command);
	serial->println(F(": unknown command"));

	commandParams.reset();
	printTerminalReady();
}