handPoseEstimation_IDL.cpp

// This is an automatically-generated file.
// It could get re-generated if the ALLOW_IDL_GENERATION flag is on.

#include <handPoseEstimation_IDL.h>
#include <yarp/os/idl/WireTypes.h>



class handPoseEstimation_IDL_start : public yarp::os::Portable {
public:
  bool _return;
  void init();
  virtual bool write(yarp::os::ConnectionWriter& connection) YARP_OVERRIDE;
  virtual bool read(yarp::os::ConnectionReader& connection) YARP_OVERRIDE;
};

class handPoseEstimation_IDL_stop : public yarp::os::Portable {
public:
  bool _return;
  void init();
  virtual bool write(yarp::os::ConnectionWriter& connection) YARP_OVERRIDE;
  virtual bool read(yarp::os::ConnectionReader& connection) YARP_OVERRIDE;
};

class handPoseEstimation_IDL_pause : public yarp::os::Portable {
public:
  bool _return;
  void init();
  virtual bool write(yarp::os::ConnectionWriter& connection) YARP_OVERRIDE;
  virtual bool read(yarp::os::ConnectionReader& connection) YARP_OVERRIDE;
};

class handPoseEstimation_IDL_resume : public yarp::os::Portable {
public:
  bool _return;
  void init();
  virtual bool write(yarp::os::ConnectionWriter& connection) YARP_OVERRIDE;
  virtual bool read(yarp::os::ConnectionReader& connection) YARP_OVERRIDE;
};

class handPoseEstimation_IDL_lastOffsets : public yarp::os::Portable {
public:
  yarp::os::Bottle _return;
  void init();
  virtual bool write(yarp::os::ConnectionWriter& connection) YARP_OVERRIDE;
  virtual bool read(yarp::os::ConnectionReader& connection) YARP_OVERRIDE;
};

class handPoseEstimation_IDL_quit : public yarp::os::Portable {
public:
  bool _return;
  void init();
  virtual bool write(yarp::os::ConnectionWriter& connection) YARP_OVERRIDE;
  virtual bool read(yarp::os::ConnectionReader& connection) YARP_OVERRIDE;
};

bool handPoseEstimation_IDL_start::write(yarp::os::ConnectionWriter& connection) {
  yarp::os::idl::WireWriter writer(connection);
  if (!writer.writeListHeader(1)) return false;
  if (!writer.writeTag("start",1,1)) return false;
  return true;
}

bool handPoseEstimation_IDL_start::read(yarp::os::ConnectionReader& connection) {
  yarp::os::idl::WireReader reader(connection);
  if (!reader.readListReturn()) return false;
  if (!reader.readBool(_return)) {
    reader.fail();
    return false;
  }
  return true;
}

void handPoseEstimation_IDL_start::init() {
  _return = false;
}

bool handPoseEstimation_IDL_stop::write(yarp::os::ConnectionWriter& connection) {
  yarp::os::idl::WireWriter writer(connection);
  if (!writer.writeListHeader(1)) return false;
  if (!writer.writeTag("stop",1,1)) return false;
  return true;
}

bool handPoseEstimation_IDL_stop::read(yarp::os::ConnectionReader& connection) {
  yarp::os::idl::WireReader reader(connection);
  if (!reader.readListReturn()) return false;
  if (!reader.readBool(_return)) {
    reader.fail();
    return false;
  }
  return true;
}

void handPoseEstimation_IDL_stop::init() {
  _return = false;
}

bool handPoseEstimation_IDL_pause::write(yarp::os::ConnectionWriter& connection) {
  yarp::os::idl::WireWriter writer(connection);
  if (!writer.writeListHeader(1)) return false;
  if (!writer.writeTag("pause",1,1)) return false;
  return true;
}

bool handPoseEstimation_IDL_pause::read(yarp::os::ConnectionReader& connection) {
  yarp::os::idl::WireReader reader(connection);
  if (!reader.readListReturn()) return false;
  if (!reader.readBool(_return)) {
    reader.fail();
    return false;
  }
  return true;
}

void handPoseEstimation_IDL_pause::init() {
  _return = false;
}

bool handPoseEstimation_IDL_resume::write(yarp::os::ConnectionWriter& connection) {
  yarp::os::idl::WireWriter writer(connection);
  if (!writer.writeListHeader(1)) return false;
  if (!writer.writeTag("resume",1,1)) return false;
  return true;
}

bool handPoseEstimation_IDL_resume::read(yarp::os::ConnectionReader& connection) {
  yarp::os::idl::WireReader reader(connection);
  if (!reader.readListReturn()) return false;
  if (!reader.readBool(_return)) {
    reader.fail();
    return false;
  }
  return true;
}

void handPoseEstimation_IDL_resume::init() {
  _return = false;
}

bool handPoseEstimation_IDL_lastOffsets::write(yarp::os::ConnectionWriter& connection) {
  yarp::os::idl::WireWriter writer(connection);
  if (!writer.writeListHeader(1)) return false;
  if (!writer.writeTag("lastOffsets",1,1)) return false;
  return true;
}

bool handPoseEstimation_IDL_lastOffsets::read(yarp::os::ConnectionReader& connection) {
  yarp::os::idl::WireReader reader(connection);
  if (!reader.readListReturn()) return false;
  if (!reader.read(_return)) {
    reader.fail();
    return false;
  }
  return true;
}

void handPoseEstimation_IDL_lastOffsets::init() {
}

bool handPoseEstimation_IDL_quit::write(yarp::os::ConnectionWriter& connection) {
  yarp::os::idl::WireWriter writer(connection);
  if (!writer.writeListHeader(1)) return false;
  if (!writer.writeTag("quit",1,1)) return false;
  return true;
}

bool handPoseEstimation_IDL_quit::read(yarp::os::ConnectionReader& connection) {
  yarp::os::idl::WireReader reader(connection);
  if (!reader.readListReturn()) return false;
  if (!reader.readBool(_return)) {
    reader.fail();
    return false;
  }
  return true;
}

void handPoseEstimation_IDL_quit::init() {
  _return = false;
}

handPoseEstimation_IDL::handPoseEstimation_IDL() {
  yarp().setOwner(*this);
}
bool handPoseEstimation_IDL::start() {
  bool _return = false;
  handPoseEstimation_IDL_start helper;
  helper.init();
  if (!yarp().canWrite()) {
    yError("Missing server method '%s'?","bool handPoseEstimation_IDL::start()");
  }
  bool ok = yarp().write(helper,helper);
  return ok?helper._return:_return;
}
bool handPoseEstimation_IDL::stop() {
  bool _return = false;
  handPoseEstimation_IDL_stop helper;
  helper.init();
  if (!yarp().canWrite()) {
    yError("Missing server method '%s'?","bool handPoseEstimation_IDL::stop()");
  }
  bool ok = yarp().write(helper,helper);
  return ok?helper._return:_return;
}
bool handPoseEstimation_IDL::pause() {
  bool _return = false;
  handPoseEstimation_IDL_pause helper;
  helper.init();
  if (!yarp().canWrite()) {
    yError("Missing server method '%s'?","bool handPoseEstimation_IDL::pause()");
  }
  bool ok = yarp().write(helper,helper);
  return ok?helper._return:_return;
}
bool handPoseEstimation_IDL::resume() {
  bool _return = false;
  handPoseEstimation_IDL_resume helper;
  helper.init();
  if (!yarp().canWrite()) {
    yError("Missing server method '%s'?","bool handPoseEstimation_IDL::resume()");
  }
  bool ok = yarp().write(helper,helper);
  return ok?helper._return:_return;
}
yarp::os::Bottle handPoseEstimation_IDL::lastOffsets() {
  yarp::os::Bottle _return;
  handPoseEstimation_IDL_lastOffsets helper;
  helper.init();
  if (!yarp().canWrite()) {
    yError("Missing server method '%s'?","yarp::os::Bottle handPoseEstimation_IDL::lastOffsets()");
  }
  bool ok = yarp().write(helper,helper);
  return ok?helper._return:_return;
}
bool handPoseEstimation_IDL::quit() {
  bool _return = false;
  handPoseEstimation_IDL_quit helper;
  helper.init();
  if (!yarp().canWrite()) {
    yError("Missing server method '%s'?","bool handPoseEstimation_IDL::quit()");
  }
  bool ok = yarp().write(helper,helper);
  return ok?helper._return:_return;
}

bool handPoseEstimation_IDL::read(yarp::os::ConnectionReader& connection) {
  yarp::os::idl::WireReader reader(connection);
  reader.expectAccept();
  if (!reader.readListHeader()) { reader.fail(); return false; }
  yarp::os::ConstString tag = reader.readTag();
  bool direct = (tag=="__direct__");
  if (direct) tag = reader.readTag();
  while (!reader.isError()) {
    // TODO: use quick lookup, this is just a test
    if (tag == "start") {
      bool _return;
      _return = start();
      yarp::os::idl::WireWriter writer(reader);
      if (!writer.isNull()) {
        if (!writer.writeListHeader(1)) return false;
        if (!writer.writeBool(_return)) return false;
      }
      reader.accept();
      return true;
    }
    if (tag == "stop") {
      bool _return;
      _return = stop();
      yarp::os::idl::WireWriter writer(reader);
      if (!writer.isNull()) {
        if (!writer.writeListHeader(1)) return false;
        if (!writer.writeBool(_return)) return false;
      }
      reader.accept();
      return true;
    }
    if (tag == "pause") {
      bool _return;
      _return = pause();
      yarp::os::idl::WireWriter writer(reader);
      if (!writer.isNull()) {
        if (!writer.writeListHeader(1)) return false;
        if (!writer.writeBool(_return)) return false;
      }
      reader.accept();
      return true;
    }
    if (tag == "resume") {
      bool _return;
      _return = resume();
      yarp::os::idl::WireWriter writer(reader);
      if (!writer.isNull()) {
        if (!writer.writeListHeader(1)) return false;
        if (!writer.writeBool(_return)) return false;
      }
      reader.accept();
      return true;
    }
    if (tag == "lastOffsets") {
      yarp::os::Bottle _return;
      _return = lastOffsets();
      yarp::os::idl::WireWriter writer(reader);
      if (!writer.isNull()) {
        if (!writer.writeListHeader(1)) return false;
        if (!writer.write(_return)) return false;
      }
      reader.accept();
      return true;
    }
    if (tag == "quit") {
      bool _return;
      _return = quit();
      yarp::os::idl::WireWriter writer(reader);
      if (!writer.isNull()) {
        if (!writer.writeListHeader(1)) return false;
        if (!writer.writeBool(_return)) return false;
      }
      reader.accept();
      return true;
    }
    if (tag == "help") {
      std::string functionName;
      if (!reader.readString(functionName)) {
        functionName = "--all";
      }
      std::vector<std::string> _return=help(functionName);
      yarp::os::idl::WireWriter writer(reader);
        if (!writer.isNull()) {
          if (!writer.writeListHeader(2)) return false;
          if (!writer.writeTag("many",1, 0)) return false;
          if (!writer.writeListBegin(BOTTLE_TAG_INT, static_cast<uint32_t>(_return.size()))) return false;
          std::vector<std::string> ::iterator _iterHelp;
          for (_iterHelp = _return.begin(); _iterHelp != _return.end(); ++_iterHelp)
          {
            if (!writer.writeString(*_iterHelp)) return false;
           }
          if (!writer.writeListEnd()) return false;
        }
      reader.accept();
      return true;
    }
    if (reader.noMore()) { reader.fail(); return false; }
    yarp::os::ConstString next_tag = reader.readTag();
    if (next_tag=="") break;
    tag = tag + "_" + next_tag;
  }
  return false;
}

std::vector<std::string> handPoseEstimation_IDL::help(const std::string& functionName) {
  bool showAll=(functionName=="--all");
  std::vector<std::string> helpString;
  if(showAll) {
    helpString.push_back("*** Available commands:");
    helpString.push_back("start");
    helpString.push_back("stop");
    helpString.push_back("pause");
    helpString.push_back("resume");
    helpString.push_back("lastOffsets");
    helpString.push_back("quit");
    helpString.push_back("help");
  }
  else {
    if (functionName=="start") {
      helpString.push_back("bool start() ");
      helpString.push_back("Start (re-start) the hand pose estimation. ");
      helpString.push_back("The filter generates particles and update the particle distribution accordingly ");
      helpString.push_back("@return true/false on success/failure ");
    }
    if (functionName=="stop") {
      helpString.push_back("bool stop() ");
      helpString.push_back("Stop the hand pose estimation. ");
      helpString.push_back("The filter stop the generation of particles and waits for a start command ");
      helpString.push_back("@return true/false on success/failure ");
    }
    if (functionName=="pause") {
      helpString.push_back("bool pause() ");
      helpString.push_back("Pause the hand pose estimation. ");
      helpString.push_back("The filter stop the generation of particles and waits for a resume command ");
      helpString.push_back("@return true/false on success/failure ");
    }
    if (functionName=="resume") {
      helpString.push_back("bool resume() ");
      helpString.push_back("Resume the hand pose estimation. ");
      helpString.push_back("The filter resumes the generation of particles after a pause command ");
      helpString.push_back("@return true/false on success/failure ");
    }
    if (functionName=="lastOffsets") {
      helpString.push_back("yarp::os::Bottle lastOffsets() ");
      helpString.push_back("Ask for the last estimated angular Offsets on the arm (7DoF) ");
      helpString.push_back("@return Bottle with last angular Offsets ");
    }
    if (functionName=="quit") {
      helpString.push_back("bool quit() ");
      helpString.push_back("Quit the module. ");
      helpString.push_back("@return true/false on success/failure ");
    }
    if (functionName=="help") {
      helpString.push_back("std::vector<std::string> help(const std::string& functionName=\"--all\")");
      helpString.push_back("Return list of available commands, or help message for a specific function");
      helpString.push_back("@param functionName name of command for which to get a detailed description. If none or '--all' is provided, print list of available commands");
      helpString.push_back("@return list of strings (one string per line)");
    }
  }
  if ( helpString.empty()) helpString.push_back("Command not found");
  return helpString;
}