mm_io_cptr
mm_multi_file_io_c::open_multi(const std::string &display_file_name,
bool single_only) {
bfs::path first_file_name(bfs::system_complete(bfs::path(display_file_name)));
std::string base_name = bfs::basename(first_file_name);
std::string extension = balg::to_lower_copy(bfs::extension(first_file_name));
boost::regex file_name_re("(.+[_\\-])(\\d+)$", boost::regex::perl);
boost::smatch matches;
if (!boost::regex_match(base_name, matches, file_name_re) || single_only) {
std::vector<bfs::path> file_names;
file_names.push_back(first_file_name);
return mm_io_cptr(new mm_multi_file_io_c(file_names, display_file_name));
}
int start_number = 1;
parse_number(matches[2].str(), start_number);
base_name = balg::to_lower_copy(matches[1].str());
std::vector<path_sorter_t> paths;
paths.push_back(path_sorter_t(first_file_name, start_number));
bfs::directory_iterator end_itr;
for (bfs::directory_iterator itr(first_file_name.branch_path()); itr != end_itr; ++itr) {
if ( bfs::is_directory(itr->status())
|| !balg::iequals(bfs::extension(itr->path()), extension))
continue;
std::string stem = bfs::basename(itr->path());
int current_number = 0;
if ( !boost::regex_match(stem, matches, file_name_re)
|| !balg::iequals(matches[1].str(), base_name)
|| !parse_number(matches[2].str(), current_number)
|| (current_number <= start_number))
continue;
paths.push_back(path_sorter_t(itr->path(), current_number));
}
std::sort(paths.begin(), paths.end());
std::vector<bfs::path> file_names;
for (auto &path : paths)
file_names.push_back(path.m_path);
return mm_io_cptr(new mm_multi_file_io_c(file_names, display_file_name));
}
static mm_io_cptr
open_input_file(filelist_t &file) {
try {
if (file.all_names.size() == 1)
return mm_io_cptr(new mm_read_buffer_io_c(new mm_file_io_c(file.name), 1 << 17));
else {
std::vector<bfs::path> paths = file_names_to_paths(file.all_names);
return mm_io_cptr(new mm_read_buffer_io_c(new mm_multi_file_io_c(paths, file.name), 1 << 17));
}
} catch (mtx::mm_io::exception &ex) {
mxerror(boost::format(Y("The file '%1%' could not be opened for reading: %2%.\n")) % file.name % ex);
return mm_io_cptr{};
} catch (...) {
mxerror(boost::format(Y("The source file '%1%' could not be opened successfully, or retrieving its size by seeking to the end did not work.\n")) % file.name);
return mm_io_cptr{};
}
}
mm_io_cptr
mm_write_cache_io_c::open(const std::string &file_name,
size_t cache_size) {
return mm_io_cptr(new mm_write_cache_io_c(new mm_file_io_c(file_name, MODE_CREATE), cache_size));
}
int
main(int argc,
char *argv[]) {
int maxlen;
uint64_t size;
unsigned char *buffer;
char mode;
std::string s, line;
mtx_common_init("base64tool", argv[0]);
set_usage();
if (argc < 4)
usage(0);
mode = 0;
if (!strcmp(argv[1], "encode"))
mode = 'e';
else if (!strcmp(argv[1], "decode"))
mode = 'd';
else
mxerror(boost::format(Y("Invalid mode '%1%'.\n")) % argv[1]);
maxlen = 72;
if ((argc == 5) && (mode == 'e')) {
if (!parse_number(argv[4], maxlen) || (maxlen < 4))
mxerror(Y("Max line length must be >= 4.\n\n"));
} else if ((argc > 5) || ((argc > 4) && (mode == 'd')))
usage(2);
maxlen = ((maxlen + 3) / 4) * 4;
mm_io_cptr in, intext;
try {
in = mm_io_cptr(new mm_file_io_c(argv[2]));
if (mode != 'e')
intext = mm_io_cptr(new mm_text_io_c(in.get(), false));
} catch (mtx::mm_io::exception &ex) {
mxerror(boost::format(Y("The file '%1%' could not be opened for reading: %2%.\n")) % argv[2] % ex);
}
mm_io_cptr out;
try {
out = mm_write_buffer_io_c::open(argv[3], 128 * 1024);
} catch (mtx::mm_io::exception &ex) {
mxerror(boost::format(Y("The file '%1%' could not be opened for writing: %2%.\n")) % argv[3] % ex);
}
in->save_pos();
in->setFilePointer(0, seek_end);
size = in->getFilePointer();
in->restore_pos();
if (mode == 'e') {
buffer = (unsigned char *)safemalloc(size);
size = in->read(buffer, size);
s = base64_encode(buffer, size, true, maxlen);
safefree(buffer);
out->write(s.c_str(), s.length());
} else {
while (intext->getline2(line)) {
strip(line);
s += line;
}
buffer = (unsigned char *)safemalloc(s.length() / 4 * 3 + 100);
try {
size = base64_decode(s, buffer);
} catch(...) {
mxerror(Y("The Base64 encoded data could not be decoded.\n"));
}
out->write(buffer, size);
safefree(buffer);
}
mxinfo(Y("Done.\n"));
mxexit(0);
}
mm_io_cptr
mm_file_io_c::open(const std::string &path,
const open_mode mode) {
return mm_io_cptr(new mm_file_io_c(path, mode));
}
