C++ Arguments::begin方法代码示例

void launchCygwin(char** argValues) {
    std::string ARGV0 = *argValues;
    ++ argValues;
    size_t lastBackslash = ARGV0.rfind('\\');
    std::string directoryPrefix;
    if (lastBackslash != std::string::npos) {
        directoryPrefix = ARGV0.substr(0, lastBackslash + 1);
    }
    
    std::string cygwinBin = findCygwinBin();
    
    const char* oldPath = getenv("PATH");
    if (oldPath == 0) {
        throw std::runtime_error("getenv(\"PATH\") implausibly returned null");
    }
    // Windows doesn't support setenv but does support putenv.
    // We need cygwin1.dll to be on the PATH.
    std::string putenvArgument = std::string("PATH=") + oldPath + ";" + cygwinBin;
    if (putenv(putenvArgument.c_str()) == -1) {
        throw unix_exception(std::string("putenv(\"") + putenvArgument + "\") failed");
    }
    checkReadableFile("Cygwin DLL", cygwinBin + "\\cygwin1.dll");
    
    // Windows requires that we quote the arguments ourselves.
    typedef std::vector<std::string> Arguments;
    Arguments arguments;
    std::string program = directoryPrefix + "ruby-launcher.exe";
    // We mustn't quote the program argument but we must quote argv[0].
    arguments.push_back(quote(program));
    // Make sure we invoke the Cygwin ruby, not any native version that might be ahead of it on the PATH.
    std::string rubyInterpreter = cygwinBin + "\\ruby.exe";
    checkReadableFile("Cygwin Ruby", rubyInterpreter);
    arguments.push_back(quote(rubyInterpreter));
    while (*argValues != 0) {
        const char* argument = *argValues;
        arguments.push_back(quote(argument));
        ++ argValues;
    }
    
    typedef std::vector<char*> ArgValues;
    ArgValues childArgValues;
    for (Arguments::iterator it = arguments.begin(), en = arguments.end(); it != en; ++ it) {
        std::string& argument = *it;
        childArgValues.push_back(&argument[0]);
    }
    childArgValues.push_back(0);
    WindowsDllErrorModeChange windowsDllErrorModeChange;
    execv(program.c_str(), &childArgValues[0]);
    throw unix_exception(std::string("execv(\"") + program + "\", [" + join(", ", arguments) + "]) failed");
}

inline std::pair<std::size_t, char **>
collection_to_argv(const Arguments &args) {
  std::size_t nargs = args.size();
  char **argv = new char *[nargs + 1];
  typename Arguments::size_type i = 0;
  for (typename Arguments::const_iterator it = args.begin(); it != args.end();
       ++it) {
    argv[i] = new char[it->size() + 1];
    std::strncpy(argv[i], it->c_str(), it->size() + 1);
    ++i;
  }
  argv[nargs] = 0;
  return std::pair<std::size_t, char **>(nargs, argv);
} // collection_to_argv

 virtual bool operator()(const std::string& request_path, const std::string& full_request_path, const Arguments& arguments, http::server::reply& reply)
 {
     OSG_INFO << "RestHttpDevice :: handling request " << full_request_path << " as user-event" << std::endl;
     
     osg::ref_ptr<osgGA::Event> event = new osgGA::Event();
     event->setName(full_request_path);
     event->setTime(getDevice()->getEventQueue()->getTime());
     
     for(Arguments::const_iterator i = arguments.begin(); i != arguments.end(); ++i)
     {
         event->setUserValue(i->first,i->second);
     }
     getDevice()->getEventQueue()->addEvent(event.get());
     
     return sendOkReply(reply);
 }

inline
std::pair< std::size_t, char** >
collection_to_posix_argv(const Arguments& args)
{
    std::size_t nargs = args.size();
    BOOST_ASSERT(nargs > 0);

    char** argv = new char*[nargs + 1];
    typename Arguments::size_type i = 0;
    for (typename Arguments::const_iterator iter = args.begin();
         iter != args.end(); iter++) {
        argv[i] = ::strdup((*iter).c_str());
        i++;
    }
    argv[nargs] = NULL;

    return std::pair< std::size_t, char ** >(nargs, argv);
}

KeywordArguments::KeywordArguments(const Arguments &args) {
  bool started = false;
  unsigned count = 0;

  for (Arguments::const_iterator it = args.begin(); it != args.end(); it++) {
    size_t equal = it->find('=');

    if (equal == string::npos) {
      if (started)
        THROWS("Positional argument '" << *it << "' at " << count
               << " not allowed after keyword");

      push_back(*it); // Add positional arg

    } else {
      started = true;
      set(it->substr(0, equal), it->substr(equal + 1));
    }

    count++;
  }
}

void convertQueryArgumentsToRPCValueParams(const Arguments& args, Rpc::Value& params)
{
    for (auto arg_it = args.begin(),
              end    = args.end();
              arg_it != end;
              ++arg_it
         )
    {
        const std::string& value = arg_it->second;
        // Prevent rpc value's type errors in EmulationOfWebCtlPlugin() rpc method: use integer type if possible.
        // Strange but original webctl client code sends integer params as strings.
        try {
            params[arg_it->first] = boost::lexical_cast<int>(value); // as int
        } catch(boost::bad_lexical_cast&) {
            try {
                params[arg_it->first] = boost::lexical_cast<unsigned int>(value); // as uint
            } catch(boost::bad_lexical_cast&) {
                params[arg_it->first] = value; // as string
            }
        }
    }
}

inline boost::shared_array<char> collection_to_win32_cmdline(const Arguments &args) 
{ 
    typedef std::vector<std::string> arguments_t; 
    arguments_t args2; 
    typename Arguments::size_type i = 0; 
    std::size_t size = 0; 
    for (typename Arguments::const_iterator it = args.begin(); it != args.end(); ++it) 
    { 
        std::string arg = *it; 

        std::string::size_type pos = 0; 
        while ( (pos = arg.find('"', pos)) != std::string::npos) 
        { 
            arg.replace(pos, 1, "\\\""); 
            pos += 2; 
        } 

        if (arg.find(' ') != std::string::npos) 
            arg = '\"' + arg + '\"'; 

        if (i++ != args.size() - 1) 
            arg += ' '; 

        args2.push_back(arg); 
        size += arg.size() + 1; 
    } 

    boost::shared_array<char> cmdline(new char[size]); 
    cmdline.get()[0] = '\0'; 
    for (arguments_t::size_type i = 0; i < args.size(); ++i) 
#if defined(__CYGWIN__) || defined(_SCL_SECURE_NO_DEPRECATE) 
        ::strncat(cmdline.get(), args2[i].c_str(), args2[i].size()); 
#else 
        ::strcat_s(cmdline.get(), size, args2[i].c_str()); 
#endif 

    return cmdline; 
} 

    int run(const Properties& options, const Arguments& arguments) {
        int r = 0;

        if ((r = checkOptions(options, arguments)) != 0) {
            return r;
        }

        // parameters
        LOG4CXX_INFO(logger, "Parameters:");
        LOG4CXX_INFO(logger, boost::format("PE Mode: %d") % options.get< int >("pe-mode", 0));
        if (options.find("min-length") != options.not_found()) {
            LOG4CXX_INFO(logger, boost::format("Min length: %d") % options.get< int >("min-length"));
        }
        if (options.find("hard-clip") != options.not_found()) {
            LOG4CXX_INFO(logger, boost::format("hard clip: %d") % options.get< int >("hard-clip"));
        }
        if (options.find("quality-trim") != options.not_found()) {
            LOG4CXX_INFO(logger, boost::format("Quality Trim: %d") % options.get< int >("quality-trim"));
        }
        if (options.find("quality-filter") != options.not_found()) {
            LOG4CXX_INFO(logger, boost::format("Quality Filter: %d") % options.get< int >("quality-filter"));
        }

        // input
        std::vector< std::string > filelist;
        std::copy(arguments.begin(), arguments.end(), std::back_inserter(filelist));
        LOG4CXX_INFO(logger, boost::format("input: %s") % boost::algorithm::join(filelist, ":"));

        // output
        std::ostream* out = &std::cout;
        if (options.find("out") != options.not_found()) {
            std::string file = options.get< std::string >("out");
            out = new std::ofstream(file.c_str());
            LOG4CXX_INFO(logger, boost::format("output: %s") % file);
        }

        // process
        if (*out) {
            Statistics stats;
            if ((r = processReads(options, filelist, *out, stats)) == 0) {
                // report statistics
                LOG4CXX_INFO(logger, "Preprocess stats:");
                LOG4CXX_INFO(logger, boost::format("Reads parsed:\t%d") % stats.numReadsRead);
                if (stats.numReadsRead > 0) {
                    LOG4CXX_INFO(logger, boost::format("Reads kept:\t%d(%f)") % stats.numReadsKept % ((double)stats.numReadsKept / stats.numReadsRead));
                    LOG4CXX_INFO(logger, boost::format("Reads failed primer screen:\t%d(%e)") % stats.numReadsPrimer % ((double)stats.numReadsPrimer / stats.numReadsRead));
                }
                LOG4CXX_INFO(logger, boost::format("Bases parsed:\t%d") % stats.numBasesRead);
                if (stats.numBasesRead) {
                    LOG4CXX_INFO(logger, boost::format("Bases kept:\t%d(%f)") % stats.numBasesKept % ((double)stats.numBasesKept / stats.numBasesRead));
                }
                LOG4CXX_INFO(logger, boost::format("Number of incorrectly paired reads that were discarded: %d") % stats.numInvalidPE);
            }
        } else {
            LOG4CXX_ERROR(logger, "Failed to open output stream");
        }

        if (out != &std::cout) {
            SAFE_DELETE(out);
        }

        return r;
    }