/***** This code was generated by Yaggo. Do not edit ******/ /* This file is part of Jellyfish. Jellyfish is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version. Jellyfish is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with Jellyfish. If not, see . */ #ifndef __HISTO_MAIN_CMDLINE_HPP__ #define __HISTO_MAIN_CMDLINE_HPP__ #include #include #include #include #include #include #include #include #include #include #include #include #include class histo_main_cmdline { // Boiler plate stuff. Conversion from string to other formats static bool adjust_double_si_suffix(double &res, const char *suffix) { if(*suffix == '\0') return true; if(*(suffix + 1) != '\0') return false; switch(*suffix) { case 'a': res *= 1e-18; break; case 'f': res *= 1e-15; break; case 'p': res *= 1e-12; break; case 'n': res *= 1e-9; break; case 'u': res *= 1e-6; break; case 'm': res *= 1e-3; break; case 'k': res *= 1e3; break; case 'M': res *= 1e6; break; case 'G': res *= 1e9; break; case 'T': res *= 1e12; break; case 'P': res *= 1e15; break; case 'E': res *= 1e18; break; default: return false; } return true; } static double conv_double(const char *str, ::std::string &err, bool si_suffix) { char *endptr = 0; errno = 0; double res = strtod(str, &endptr); if(errno) { err.assign(strerror(errno)); return (double)0.0; } bool invalid = si_suffix ? !adjust_double_si_suffix(res, endptr) : *endptr != '\0'; if(invalid) { err.assign("Invalid character"); return (double)0.0; } return res; } static int conv_enum(const char* str, ::std::string& err, const char* const strs[]) { int res = 0; for(const char* const* cstr = strs; *cstr; ++cstr, ++res) if(!strcmp(*cstr, str)) return res; err += "Invalid constant '"; err += str; err += "'. Expected one of { "; for(const char* const* cstr = strs; *cstr; ++cstr) { if(cstr != strs) err += ", "; err += *cstr; } err += " }"; return -1; } template static bool adjust_int_si_suffix(T &res, const char *suffix) { if(*suffix == '\0') return true; if(*(suffix + 1) != '\0') return false; switch(*suffix) { case 'k': res *= (T)1000; break; case 'M': res *= (T)1000000; break; case 'G': res *= (T)1000000000; break; case 'T': res *= (T)1000000000000; break; case 'P': res *= (T)1000000000000000; break; case 'E': res *= (T)1000000000000000000; break; default: return false; } return true; } template static T conv_int(const char *str, ::std::string &err, bool si_suffix) { char *endptr = 0; errno = 0; long long int res = strtoll(str, &endptr, 0); if(errno) { err.assign(strerror(errno)); return (T)0; } bool invalid = si_suffix ? !adjust_int_si_suffix(res, endptr) : *endptr != '\0'; if(invalid) { err.assign("Invalid character"); return (T)0; } if(res > ::std::numeric_limits::max() || res < ::std::numeric_limits::min()) { err.assign("Value out of range"); return (T)0; } return (T)res; } template static T conv_uint(const char *str, ::std::string &err, bool si_suffix) { char *endptr = 0; errno = 0; while(isspace(*str)) { ++str; } if(*str == '-') { err.assign("Negative value"); return (T)0; } unsigned long long int res = strtoull(str, &endptr, 0); if(errno) { err.assign(strerror(errno)); return (T)0; } bool invalid = si_suffix ? !adjust_int_si_suffix(res, endptr) : *endptr != '\0'; if(invalid) { err.assign("Invalid character"); return (T)0; } if(res > ::std::numeric_limits::max()) { err.assign("Value out of range"); return (T)0; } return (T)res; } template static ::std::string vec_str(const std::vector &vec) { ::std::ostringstream os; for(typename ::std::vector::const_iterator it = vec.begin(); it != vec.end(); ++it) { if(it != vec.begin()) os << ","; os << *it; } return os.str(); } class string : public ::std::string { public: string() : ::std::string() {} explicit string(const ::std::string &s) : std::string(s) {} explicit string(const char *s) : ::std::string(s) {} int as_enum(const char* const strs[]) { ::std::string err; int res = conv_enum((const char*)this->c_str(), err, strs); if(!err.empty()) throw ::std::runtime_error(err); return res; } uint32_t as_uint32_suffix() const { return as_uint32(true); } uint32_t as_uint32(bool si_suffix = false) const { ::std::string err; uint32_t res = conv_uint((const char*)this->c_str(), err, si_suffix); if(!err.empty()) { ::std::string msg("Invalid conversion of '"); msg += *this; msg += "' to uint32_t: "; msg += err; throw ::std::runtime_error(msg); } return res; } uint64_t as_uint64_suffix() const { return as_uint64(true); } uint64_t as_uint64(bool si_suffix = false) const { ::std::string err; uint64_t res = conv_uint((const char*)this->c_str(), err, si_suffix); if(!err.empty()) { ::std::string msg("Invalid conversion of '"); msg += *this; msg += "' to uint64_t: "; msg += err; throw ::std::runtime_error(msg); } return res; } int32_t as_int32_suffix() const { return as_int32(true); } int32_t as_int32(bool si_suffix = false) const { ::std::string err; int32_t res = conv_int((const char*)this->c_str(), err, si_suffix); if(!err.empty()) { ::std::string msg("Invalid conversion of '"); msg += *this; msg += "' to int32_t: "; msg += err; throw ::std::runtime_error(msg); } return res; } int64_t as_int64_suffix() const { return as_int64(true); } int64_t as_int64(bool si_suffix = false) const { ::std::string err; int64_t res = conv_int((const char*)this->c_str(), err, si_suffix); if(!err.empty()) { ::std::string msg("Invalid conversion of '"); msg += *this; msg += "' to int64_t: "; msg += err; throw ::std::runtime_error(msg); } return res; } int as_int_suffix() const { return as_int(true); } int as_int(bool si_suffix = false) const { ::std::string err; int res = conv_int((const char*)this->c_str(), err, si_suffix); if(!err.empty()) { ::std::string msg("Invalid conversion of '"); msg += *this; msg += "' to int_t: "; msg += err; throw ::std::runtime_error(msg); } return res; } long as_long_suffix() const { return as_long(true); } long as_long(bool si_suffix = false) const { ::std::string err; long res = conv_int((const char*)this->c_str(), err, si_suffix); if(!err.empty()) { ::std::string msg("Invalid conversion of '"); msg += *this; msg += "' to long_t: "; msg += err; throw ::std::runtime_error(msg); } return res; } double as_double_suffix() const { return as_double(true); } double as_double(bool si_suffix = false) const { ::std::string err; double res = conv_double((const char*)this->c_str(), err, si_suffix); if(!err.empty()) { ::std::string msg("Invalid conversion of '"); msg += *this; msg += "' to double_t: "; msg += err; throw ::std::runtime_error(msg); } return res; } }; public: uint64_t low_arg; bool low_given; uint64_t high_arg; bool high_given; uint64_t increment_arg; bool increment_given; uint32_t threads_arg; bool threads_given; bool full_flag; const char * output_arg; bool output_given; uint64_t buffer_size_arg; bool buffer_size_given; bool verbose_flag; const char * db_arg; enum { START_OPT = 1000, FULL_HELP_OPT, HELP_OPT }; histo_main_cmdline() : low_arg((uint64_t)1), low_given(false), high_arg((uint64_t)10000), high_given(false), increment_arg((uint64_t)1), increment_given(false), threads_arg((uint32_t)1), threads_given(false), full_flag(false), output_arg(""), output_given(false), buffer_size_arg((uint64_t)10000000), buffer_size_given(false), verbose_flag(false), db_arg("") { } histo_main_cmdline(int argc, char* argv[]) : low_arg((uint64_t)1), low_given(false), high_arg((uint64_t)10000), high_given(false), increment_arg((uint64_t)1), increment_given(false), threads_arg((uint32_t)1), threads_given(false), full_flag(false), output_arg(""), output_given(false), buffer_size_arg((uint64_t)10000000), buffer_size_given(false), verbose_flag(false), db_arg("") { parse(argc, argv); } void parse(int argc, char* argv[]) { static struct option long_options[] = { {"low", 1, 0, 'l'}, {"high", 1, 0, 'h'}, {"increment", 1, 0, 'i'}, {"threads", 1, 0, 't'}, {"full", 0, 0, 'f'}, {"output", 1, 0, 'o'}, {"buffer-size", 1, 0, 's'}, {"verbose", 0, 0, 'v'}, {"help", 0, 0, HELP_OPT}, {"full-help", 0, 0, FULL_HELP_OPT}, {"usage", 0, 0, 'U'}, {"version", 0, 0, 'V'}, {0, 0, 0, 0} }; static const char *short_options = "VUl:h:i:t:fo:s:v"; ::std::string err; #define CHECK_ERR(type,val,which) if(!err.empty()) { ::std::cerr << "Invalid " #type " '" << val << "' for [" which "]: " << err << "\n"; exit(1); } while(true) { int index = -1; int c = getopt_long(argc, argv, short_options, long_options, &index); if(c == -1) break; switch(c) { case ':': ::std::cerr << "Missing required argument for " << (index == -1 ? ::std::string(1, (char)optopt) : std::string(long_options[index].name)) << ::std::endl; exit(1); case HELP_OPT: ::std::cout << usage() << "\n\n" << help() << std::endl; exit(0); case 'U': ::std::cout << usage() << "\nUse --help for more information." << std::endl; exit(0); case 'V': print_version(); exit(0); case '?': ::std::cerr << "Use --usage or --help for some help\n"; exit(1); case FULL_HELP_OPT: ::std::cout << usage() << "\n\n" << help() << "\n\n" << hidden() << std::flush; exit(0); case 'l': low_given = true; low_arg = conv_uint((const char*)optarg, err, false); CHECK_ERR(uint64_t, optarg, "-l, --low=uint64") break; case 'h': high_given = true; high_arg = conv_uint((const char*)optarg, err, false); CHECK_ERR(uint64_t, optarg, "-h, --high=uint64") break; case 'i': increment_given = true; increment_arg = conv_uint((const char*)optarg, err, false); CHECK_ERR(uint64_t, optarg, "-i, --increment=uint64") break; case 't': threads_given = true; threads_arg = conv_uint((const char*)optarg, err, false); CHECK_ERR(uint32_t, optarg, "-t, --threads=uint32") break; case 'f': full_flag = true; break; case 'o': output_given = true; output_arg = optarg; break; case 's': buffer_size_given = true; buffer_size_arg = conv_uint((const char*)optarg, err, true); CHECK_ERR(uint64_t, optarg, "-s, --buffer-size=Buffer length") break; case 'v': verbose_flag = true; break; } } // Parse arguments if(argc - optind != 1) error("Requires exactly 1 argument."); db_arg = argv[optind]; ++optind; } static const char * usage() { return "Usage: jellyfish histo [options] db:path"; } class error { int code_; std::ostringstream msg_; // Select the correct version (GNU or XSI) version of // strerror_r. strerror_ behaves like the GNU version of strerror_r, // regardless of which version is provided by the system. static const char* strerror__(char* buf, int res) { return res != -1 ? buf : "Invalid error"; } static const char* strerror__(char* buf, char* res) { return res; } static const char* strerror_(int err, char* buf, size_t buflen) { return strerror__(buf, strerror_r(err, buf, buflen)); } struct no_t { }; public: static no_t no; error(int code = EXIT_FAILURE) : code_(code) { } explicit error(const char* msg, int code = EXIT_FAILURE) : code_(code) { msg_ << msg; } error(const std::string& msg, int code = EXIT_FAILURE) : code_(code) { msg_ << msg; } error& operator<<(no_t) { char buf[1024]; msg_ << ": " << strerror_(errno, buf, sizeof(buf)); return *this; } template error& operator<<(const T& x) { msg_ << x; return (*this); } ~error() { ::std::cerr << "Error: " << msg_.str() << "\n" << usage() << "\n" << "Use --help for more information" << ::std::endl; exit(code_); } }; static const char * help() { return "Create an histogram of k-mer occurrences\n\nCreate an histogram with the number of k-mers having a given\n" \ "count. In bucket 'i' are tallied the k-mers which have a count 'c'\n" \ "satisfying 'low+i*inc <= c < low+(i+1)*inc'. Buckets in the output are\n" \ "labeled by the low end point (low+i*inc).\n" \ "\n" \ "The last bucket in the output behaves as a catchall: it tallies all\n" \ "k-mers with a count greater or equal to the low end point of this\n" \ "bucket.\n\n" "Options (default value in (), *required):\n" " -l, --low=uint64 Low count value of histogram (1)\n" " -h, --high=uint64 High count value of histogram (10000)\n" " -i, --increment=uint64 Increment value for buckets (1)\n" " -t, --threads=uint32 Number of threads (1)\n" " -f, --full Full histo. Don't skip count 0. (false)\n" " -o, --output=string Output file\n" " -v, --verbose Output information (false)\n" " -U, --usage Usage\n" " --help This message\n" " --full-help Detailed help\n" " -V, --version Version"; } static const char* hidden() { return "Hidden options:\n" " -s, --buffer-size=Buffer length Length in bytes of input buffer (10000000)\n" ""; } void print_version(::std::ostream &os = std::cout) const { #ifndef PACKAGE_VERSION #define PACKAGE_VERSION "0.0.0" #endif os << PACKAGE_VERSION << "\n"; } void dump(::std::ostream &os = std::cout) { os << "low_given:" << low_given << " low_arg:" << low_arg << "\n"; os << "high_given:" << high_given << " high_arg:" << high_arg << "\n"; os << "increment_given:" << increment_given << " increment_arg:" << increment_arg << "\n"; os << "threads_given:" << threads_given << " threads_arg:" << threads_arg << "\n"; os << "full_flag:" << full_flag << "\n"; os << "output_given:" << output_given << " output_arg:" << output_arg << "\n"; os << "buffer_size_given:" << buffer_size_given << " buffer_size_arg:" << buffer_size_arg << "\n"; os << "verbose_flag:" << verbose_flag << "\n"; os << "db_arg:" << db_arg << "\n"; } }; #endif // __HISTO_MAIN_CMDLINE_HPP__"