source/viewer/instructions/Instruction.cpp

Go to the documentation of this file.

/*
 * Copyright (c) 2007, 2008, 2009, University of Karlsruhe (for members see AUTHORS file)
 *
 * ISC License
 *
 * Permission to use, copy, modify, and/or distribute this software for any
 * purpose with or without fee is hereby granted, provided that the above
 * copyright notice and this permission notice appear in all copies.
 *
 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 *
 * Created by Alexander Bierbaum
 */

#include "../include/IPSA/viewer/instructions/Instruction.h"

#include <algorithm>
#include <iostream>
#include <sstream>
#include <iterator>

Instruction::Instruction(const std::string& code)
: I_CODE(code)
{
                if (I_CODE.empty())
                                std::cout << "Instruction with no help string!!!!" << std::endl;
                std::string::size_type j = code.find_first_not_of(" ");
                while (j != code.npos)
                {
                                std::string::size_type k = code.find(" ",j);
                                if (k == code.npos)
                                {
                                                instrdata.push_back(code.substr(j,code.size()-j));
                                                j = code.npos;
                                }
                                else
                                {
                                                instrdata.push_back(code.substr(j,k-j));
                                                j = code.find_first_not_of(" ",k);
                                }
                }
}


bool Instruction::findAndExecute(std::vector<std::string>& instr, std::ostringstream& answer, unsigned int& numberOfReturnValues)
{
                if (instr.empty() || instr[0] != instrdata[0])
                                return false;

                bool result = false;
                // print the given instruction on the commandline
                std::cout << "cmd: ";
                std::copy(instr.begin(), instr.end(), std::ostream_iterator<std::string>(std::cout, " "));
                std::cout << "... ";

                // execute the given instruction
        if(instr.size() == instrdata.size() )
        {
                                tExecResultType res = vExecute(instr,answer, numberOfReturnValues);

                                switch (res)
                                {
                                                case eUNKNOWN_ERROR: printf("unknown error occured!\n"); break;
                                                case eJOINT_NOT_FOUND: printf("joint not found!\n"); break;
                                                case eBODY_NOT_FOUND: printf("body not found!\n"); break;
                                                case eJOINT_TYPE_INCOMPATIBLE: printf("joint type incompatible!\n"); break;
                                                case eNODE_IS_NOT_A_BODY: printf("node is not a body!\n"); break;
                                                case eOK: printf("done.\n"); result = true; break;
                                                default: printf("unknown result type!\n"); break;
                                }
        }
        else
        {
                                answer << std::endl; // To avoid hangs when reading from a blocking socket
                                printf("ERROR,got %d instead of %d arguments:\n \t[ ", (int)instr.size(),
                                       (int)instrdata.size());
                                std::copy(instrdata.begin(), instrdata.end(), std::ostream_iterator<std::string>(std::cout, " "));
                                printf("]\n");
        }
                return result;
}


std::string Instruction::getCmdString()
{
        return instrdata.at(0);
}


std::string Instruction::getCmdHelpString()
{
        return I_CODE;
}


unsigned int Instruction::getCommandParameterCount()
{
                // one less because the first element is the name of the command
                return (instrdata.size() - 1);
}

---