octoleo/qpdf
2
1
Fork 0
mirror of https://github.com/qpdf/qpdf.git synced 2024-11-14 00:34:03 +00:00
Code Issues Releases Wiki Activity
9106a5e308
qpdf/libqpdf/QPDFJob_config.cc

1318 lines
30 KiB
C++
Raw Normal View History

QPDFJob: start real API Create QPDFJob_options.cc to hold API implementation functions. Reorganize a little in preparation for moving public member variables private and creating the real QPDFJob API that will be used by callers as well as the argv/json initialization methods.
2022-01-23 14:46:02 +00:00
#include <qpdf/QPDFJob.hh>
Add a blank line after the first header included in each source
2022-02-04 21:31:31 +00:00
Implement --set-page-labels and supporting API (fixes #939)
2024-01-05 21:11:09 +00:00
#include <regex>
Use the default logger for other writes to stdout/stderr When there is no context for writing output or error messages, use the default logger.
2022-06-18 14:33:27 +00:00
#include <qpdf/QPDFLogger.hh>
QPDFJob: move more top-level trivial handlers into config
2022-01-26 00:21:46 +00:00
#include <qpdf/QTC.hh>
Programmatically apply new formatting to code Run this: for i in **/*.cc **/*.c **/*.h **/*.hh; do clang-format < $i >| $i.new && mv $i.new $i done
2022-04-02 21:14:10 +00:00
#include <qpdf/QUtil.hh>
QPDFJob: begin configuration API with verbose
2022-01-24 00:29:18 +00:00
QPDFJob: add checkConfiguration to Config
2022-01-29 14:01:20 +00:00
void
QPDFJob::Config::checkConfiguration()
{
o.checkConfiguration();
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
QPDFJob::Config*
Make QPDFArgParser accept const argv This makes it much more convention to use the initializeFromArgv functions since you can use string literals.
2022-02-01 18:37:31 +00:00
QPDFJob::Config::inputFile(std::string const& filename)
QPDFJob: move input/output handling into config
2022-01-26 18:56:13 +00:00
{
Code tidy : replace 0 with nullptr or true
2022-07-26 11:37:50 +00:00
if (o.m->infilename == nullptr) {
QPDFJob: move private members into Members
2022-01-26 19:56:24 +00:00
o.m->infilename = QUtil::make_shared_cstr(filename);
Programmatically apply new formatting to code Run this: for i in **/*.cc **/*.c **/*.h **/*.hh; do clang-format < $i >| $i.new && mv $i.new $i done
2022-04-02 21:14:10 +00:00
} else {
QPDFJob: move input/output handling into config
2022-01-26 18:56:13 +00:00
usage("input file has already been given");
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
return this;
QPDFJob: move input/output handling into config
2022-01-26 18:56:13 +00:00
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
QPDFJob::Config*
QPDFJob: move input/output handling into config
2022-01-26 18:56:13 +00:00
QPDFJob::Config::emptyInput()
{
Code tidy : replace 0 with nullptr or true
2022-07-26 11:37:50 +00:00
if (o.m->infilename == nullptr) {
Code tidy - reflow comments and strings
2023-05-27 17:19:52 +00:00
// Various places in QPDFJob.cc know that the empty string for infile means empty. We set it
// to something other than a null pointer as an indication that some input source has been
// specified. This approach means that passing "" as the argument to inputFile in job JSON,
// or equivalently using "" as a positional command-line argument would be the same as
// --empty. This probably isn't worth blocking or coding around.
QPDFJob: move private members into Members
2022-01-26 19:56:24 +00:00
o.m->infilename = QUtil::make_shared_cstr("");
Programmatically apply new formatting to code Run this: for i in **/*.cc **/*.c **/*.h **/*.hh; do clang-format < $i >| $i.new && mv $i.new $i done
2022-04-02 21:14:10 +00:00
} else {
Code tidy - reflow comments and strings
2023-05-27 17:19:52 +00:00
usage("empty input can't be used since input file has already been given");
QPDFJob: move input/output handling into config
2022-01-26 18:56:13 +00:00
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
return this;
QPDFJob: move input/output handling into config
2022-01-26 18:56:13 +00:00
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
QPDFJob::Config*
Make QPDFArgParser accept const argv This makes it much more convention to use the initializeFromArgv functions since you can use string literals.
2022-02-01 18:37:31 +00:00
QPDFJob::Config::outputFile(std::string const& filename)
QPDFJob: move input/output handling into config
2022-01-26 18:56:13 +00:00
{
Code tidy : replace 0 with nullptr or true
2022-07-26 11:37:50 +00:00
if ((o.m->outfilename == nullptr) && (!o.m->replace_input)) {
QPDFJob: move private members into Members
2022-01-26 19:56:24 +00:00
o.m->outfilename = QUtil::make_shared_cstr(filename);
Programmatically apply new formatting to code Run this: for i in **/*.cc **/*.c **/*.h **/*.hh; do clang-format < $i >| $i.new && mv $i.new $i done
2022-04-02 21:14:10 +00:00
} else {
QPDFJob: move input/output handling into config
2022-01-26 18:56:13 +00:00
usage("output file has already been given");
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
return this;
QPDFJob: move input/output handling into config
2022-01-26 18:56:13 +00:00
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
QPDFJob::Config*
QPDFJob: move input/output handling into config
2022-01-26 18:56:13 +00:00
QPDFJob::Config::replaceInput()
{
Code tidy : replace 0 with nullptr or true
2022-07-26 11:37:50 +00:00
if ((o.m->outfilename == nullptr) && (!o.m->replace_input)) {
QPDFJob: move private members into Members
2022-01-26 19:56:24 +00:00
o.m->replace_input = true;
Programmatically apply new formatting to code Run this: for i in **/*.cc **/*.c **/*.h **/*.hh; do clang-format < $i >| $i.new && mv $i.new $i done
2022-04-02 21:14:10 +00:00
} else {
Code tidy - reflow comments and strings
2023-05-27 17:19:52 +00:00
usage("replace-input can't be used since output file has already been given");
QPDFJob: move input/output handling into config
2022-01-26 18:56:13 +00:00
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
return this;
QPDFJob: move input/output handling into config
2022-01-26 18:56:13 +00:00
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
QPDFJob::Config*
QPDFJob: convert trivial functions to config API
2022-01-24 00:46:20 +00:00
QPDFJob::Config::allowWeakCrypto()
{
QPDFJob: move private members into Members
2022-01-26 19:56:24 +00:00
o.m->allow_weak_crypto = true;
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
return this;
QPDFJob: convert trivial functions to config API
2022-01-24 00:46:20 +00:00
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
QPDFJob::Config*
QPDFJob: convert trivial functions to config API
2022-01-24 00:46:20 +00:00
QPDFJob::Config::check()
{
QPDFJob: move private members into Members
2022-01-26 19:56:24 +00:00
o.m->check = true;
o.m->require_outfile = false;
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
return this;
QPDFJob: convert trivial functions to config API
2022-01-24 00:46:20 +00:00
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
QPDFJob::Config*
QPDFJob: convert trivial functions to config API
2022-01-24 00:46:20 +00:00
QPDFJob::Config::checkLinearization()
{
QPDFJob: move private members into Members
2022-01-26 19:56:24 +00:00
o.m->check_linearization = true;
o.m->require_outfile = false;
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
return this;
QPDFJob: convert trivial functions to config API
2022-01-24 00:46:20 +00:00
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
QPDFJob::Config*
QPDFJob: convert trivial functions to config API
2022-01-24 00:46:20 +00:00
QPDFJob::Config::coalesceContents()
{
QPDFJob: move private members into Members
2022-01-26 19:56:24 +00:00
o.m->coalesce_contents = true;
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
return this;
QPDFJob: convert trivial functions to config API
2022-01-24 00:46:20 +00:00
}
generate_auto_job: generate overloaded config decls for optional For optional parameter/choices, generate an overloaded config method that takes no arguments. This makes it possible to convert from a bare argument to one that takes an optional parameter without breaking binary compatibility.
2022-02-01 09:16:58 +00:00
QPDFJob::Config*
QPDFJob::Config::collate()
{
Make QPDFArgParser accept const argv This makes it much more convention to use the initializeFromArgv functions since you can use string literals.
2022-02-01 18:37:31 +00:00
return collate("");
generate_auto_job: generate overloaded config decls for optional For optional parameter/choices, generate an overloaded config method that takes no arguments. This makes it possible to convert from a bare argument to one that takes an optional parameter without breaking binary compatibility.
2022-02-01 09:16:58 +00:00
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
QPDFJob::Config*
Make QPDFArgParser accept const argv This makes it much more convention to use the initializeFromArgv functions since you can use string literals.
2022-02-01 18:37:31 +00:00
QPDFJob::Config::collate(std::string const& parameter)
QPDFJob: convert trivial functions to config API
2022-01-24 00:46:20 +00:00
{
Support comma-separated numeric values with --collate (fixes #505)
2024-01-01 23:55:45 +00:00
if (parameter.empty()) {
o.m->collate.push_back(1);
return this;
}
size_t pos = 0;
// Parse a,b,c
while (true) {
auto end = parameter.find(',', pos);
auto n = parameter.substr(pos, end);
if (n.empty()) {
usage("--collate: trailing comma");
}
o.m->collate.push_back(QIntC::to_size(QUtil::string_to_uint(n.c_str())));
if (end == std::string::npos) {
break;
}
pos = end + 1;
}
if (o.m->collate.empty()) {
o.m->collate.push_back(1);
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
return this;
QPDFJob: convert trivial functions to config API
2022-01-24 00:46:20 +00:00
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
QPDFJob::Config*
Make QPDFArgParser accept const argv This makes it much more convention to use the initializeFromArgv functions since you can use string literals.
2022-02-01 18:37:31 +00:00
QPDFJob::Config::compressStreams(std::string const& parameter)
QPDFJob: convert trivial functions to config API
2022-01-24 00:46:20 +00:00
{
QPDFJob: move private members into Members
2022-01-26 19:56:24 +00:00
o.m->compress_streams_set = true;
Make QPDFArgParser accept const argv This makes it much more convention to use the initializeFromArgv functions since you can use string literals.
2022-02-01 18:37:31 +00:00
o.m->compress_streams = (parameter == "y");
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
return this;
QPDFJob: convert trivial functions to config API
2022-01-24 00:46:20 +00:00
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
QPDFJob::Config*
Make QPDFArgParser accept const argv This makes it much more convention to use the initializeFromArgv functions since you can use string literals.
2022-02-01 18:37:31 +00:00
QPDFJob::Config::compressionLevel(std::string const& parameter)
QPDFJob: convert trivial functions to config API
2022-01-24 00:46:20 +00:00
{
Make QPDFArgParser accept const argv This makes it much more convention to use the initializeFromArgv functions since you can use string literals.
2022-02-01 18:37:31 +00:00
o.m->compression_level = QUtil::string_to_int(parameter.c_str());
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
return this;
QPDFJob: convert trivial functions to config API
2022-01-24 00:46:20 +00:00
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
QPDFJob::Config*
Make QPDFArgParser accept const argv This makes it much more convention to use the initializeFromArgv functions since you can use string literals.
2022-02-01 18:37:31 +00:00
QPDFJob::Config::copyEncryption(std::string const& parameter)
QPDFJob: convert trivial functions to config API
2022-01-24 00:46:20 +00:00
{
QPDFJob: move private members into Members
2022-01-26 19:56:24 +00:00
o.m->encryption_file = parameter;
o.m->copy_encryption = true;
o.m->encrypt = false;
o.m->decrypt = false;
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
return this;
QPDFJob: convert trivial functions to config API
2022-01-24 00:46:20 +00:00
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
QPDFJob::Config*
QPDFJob: convert trivial functions to config API
2022-01-24 00:46:20 +00:00
QPDFJob::Config::decrypt()
{
QPDFJob: move private members into Members
2022-01-26 19:56:24 +00:00
o.m->decrypt = true;
o.m->encrypt = false;
o.m->copy_encryption = false;
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
return this;
QPDFJob: convert trivial functions to config API
2022-01-24 00:46:20 +00:00
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
QPDFJob::Config*
QPDFJob: convert trivial functions to config API
2022-01-24 00:46:20 +00:00
QPDFJob::Config::deterministicId()
{
QPDFJob: move private members into Members
2022-01-26 19:56:24 +00:00
o.m->deterministic_id = true;
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
return this;
QPDFJob: convert trivial functions to config API
2022-01-24 00:46:20 +00:00
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
QPDFJob::Config*
Make QPDFArgParser accept const argv This makes it much more convention to use the initializeFromArgv functions since you can use string literals.
2022-02-01 18:37:31 +00:00
QPDFJob::Config::encryptionFilePassword(std::string const& parameter)
QPDFJob: convert trivial functions to config API
2022-01-24 00:46:20 +00:00
{
QPDFJob: move private members into Members
2022-01-26 19:56:24 +00:00
o.m->encryption_file_password = QUtil::make_shared_cstr(parameter);
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
return this;
QPDFJob: convert trivial functions to config API
2022-01-24 00:46:20 +00:00
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
QPDFJob::Config*
QPDFJob: convert trivial functions to config API
2022-01-24 00:46:20 +00:00
QPDFJob::Config::externalizeInlineImages()
{
QPDFJob: move private members into Members
2022-01-26 19:56:24 +00:00
o.m->externalize_inline_images = true;
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
return this;
QPDFJob: convert trivial functions to config API
2022-01-24 00:46:20 +00:00
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
QPDFJob::Config*
QPDFJob: convert trivial functions to config API
2022-01-24 00:46:20 +00:00
QPDFJob::Config::filteredStreamData()
{
QPDFJob: move private members into Members
2022-01-26 19:56:24 +00:00
o.m->show_filtered_stream_data = true;
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
return this;
QPDFJob: convert trivial functions to config API
2022-01-24 00:46:20 +00:00
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
QPDFJob::Config*
Make QPDFArgParser accept const argv This makes it much more convention to use the initializeFromArgv functions since you can use string literals.
2022-02-01 18:37:31 +00:00
QPDFJob::Config::flattenAnnotations(std::string const& parameter)
QPDFJob: convert trivial functions to config API
2022-01-24 00:46:20 +00:00
{
QPDFJob: move private members into Members
2022-01-26 19:56:24 +00:00
o.m->flatten_annotations = true;
Programmatically apply new formatting to code Run this: for i in **/*.cc **/*.c **/*.h **/*.hh; do clang-format < $i >| $i.new && mv $i.new $i done
2022-04-02 21:14:10 +00:00
if (parameter == "screen") {
QPDFJob: move private members into Members
2022-01-26 19:56:24 +00:00
o.m->flatten_annotations_forbidden |= an_no_view;
Programmatically apply new formatting to code Run this: for i in **/*.cc **/*.c **/*.h **/*.hh; do clang-format < $i >| $i.new && mv $i.new $i done
2022-04-02 21:14:10 +00:00
} else if (parameter == "print") {
QPDFJob: move private members into Members
2022-01-26 19:56:24 +00:00
o.m->flatten_annotations_required |= an_print;
Programmatically apply new formatting to code Run this: for i in **/*.cc **/*.c **/*.h **/*.hh; do clang-format < $i >| $i.new && mv $i.new $i done
2022-04-02 21:14:10 +00:00
} else if (parameter != "all") {
Make QPDFArgParser accept const argv This makes it much more convention to use the initializeFromArgv functions since you can use string literals.
2022-02-01 18:37:31 +00:00
usage("invalid flatten-annotations option");
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
return this;
QPDFJob: convert trivial functions to config API
2022-01-24 00:46:20 +00:00
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
QPDFJob::Config*
QPDFJob: convert trivial functions to config API
2022-01-24 00:46:20 +00:00
QPDFJob::Config::flattenRotation()
{
QPDFJob: move private members into Members
2022-01-26 19:56:24 +00:00
o.m->flatten_rotation = true;
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
return this;
QPDFJob: convert trivial functions to config API
2022-01-24 00:46:20 +00:00
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
QPDFJob::Config*
Make QPDFArgParser accept const argv This makes it much more convention to use the initializeFromArgv functions since you can use string literals.
2022-02-01 18:37:31 +00:00
QPDFJob::Config::forceVersion(std::string const& parameter)
QPDFJob: convert trivial functions to config API
2022-01-24 00:46:20 +00:00
{
QPDFJob: move private members into Members
2022-01-26 19:56:24 +00:00
o.m->force_version = parameter;
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
return this;
QPDFJob: convert trivial functions to config API
2022-01-24 00:46:20 +00:00
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
QPDFJob::Config*
QPDFJob: convert trivial functions to config API
2022-01-24 00:46:20 +00:00
QPDFJob::Config::generateAppearances()
{
QPDFJob: move private members into Members
2022-01-26 19:56:24 +00:00
o.m->generate_appearances = true;
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
return this;
QPDFJob: convert trivial functions to config API
2022-01-24 00:46:20 +00:00
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
QPDFJob::Config*
QPDFJob: convert trivial functions to config API
2022-01-24 00:46:20 +00:00
QPDFJob::Config::ignoreXrefStreams()
{
QPDFJob: move private members into Members
2022-01-26 19:56:24 +00:00
o.m->ignore_xref_streams = true;
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
return this;
QPDFJob: convert trivial functions to config API
2022-01-24 00:46:20 +00:00
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
QPDFJob::Config*
Make QPDFArgParser accept const argv This makes it much more convention to use the initializeFromArgv functions since you can use string literals.
2022-02-01 18:37:31 +00:00
QPDFJob::Config::iiMinBytes(std::string const& parameter)
QPDFJob: convert trivial functions to config API
2022-01-24 00:46:20 +00:00
{
Make QPDFArgParser accept const argv This makes it much more convention to use the initializeFromArgv functions since you can use string literals.
2022-02-01 18:37:31 +00:00
o.m->ii_min_bytes = QUtil::string_to_uint(parameter.c_str());
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
return this;
QPDFJob: convert trivial functions to config API
2022-01-24 00:46:20 +00:00
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
QPDFJob::Config*
QPDFJob: convert trivial functions to config API
2022-01-24 00:46:20 +00:00
QPDFJob::Config::isEncrypted()
{
QPDFJob: move private members into Members
2022-01-26 19:56:24 +00:00
o.m->check_is_encrypted = true;
o.m->require_outfile = false;
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
return this;
QPDFJob: convert trivial functions to config API
2022-01-24 00:46:20 +00:00
}
generate_auto_job: generate overloaded config decls for optional For optional parameter/choices, generate an overloaded config method that takes no arguments. This makes it possible to convert from a bare argument to one that takes an optional parameter without breaking binary compatibility.
2022-02-01 09:16:58 +00:00
QPDFJob::Config*
QPDFJob::Config::json()
{
Make QPDFArgParser accept const argv This makes it much more convention to use the initializeFromArgv functions since you can use string literals.
2022-02-01 18:37:31 +00:00
return json("");
generate_auto_job: generate overloaded config decls for optional For optional parameter/choices, generate an overloaded config method that takes no arguments. This makes it possible to convert from a bare argument to one that takes an optional parameter without breaking binary compatibility.
2022-02-01 09:16:58 +00:00
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
QPDFJob::Config*
Make QPDFArgParser accept const argv This makes it much more convention to use the initializeFromArgv functions since you can use string literals.
2022-02-01 18:37:31 +00:00
QPDFJob::Config::json(std::string const& parameter)
QPDFJob: convert trivial functions to config API
2022-01-24 00:46:20 +00:00
{
Change default --json from 1 to latest
2022-04-16 16:57:33 +00:00
if (parameter.empty() || (parameter == "latest")) {
Prepare code for JSON v2 Update getJSON() methods and calls to them
2022-05-07 11:53:45 +00:00
o.m->json_version = JSON::LATEST;
Programmatically apply new formatting to code Run this: for i in **/*.cc **/*.c **/*.h **/*.hh; do clang-format < $i >| $i.new && mv $i.new $i done
2022-04-02 21:14:10 +00:00
} else {
Make QPDFArgParser accept const argv This makes it much more convention to use the initializeFromArgv functions since you can use string literals.
2022-02-01 18:37:31 +00:00
o.m->json_version = QUtil::string_to_int(parameter.c_str());
}
Prepare code for JSON v2 Update getJSON() methods and calls to them
2022-05-07 11:53:45 +00:00
if ((o.m->json_version < 1) || (o.m->json_version > JSON::LATEST)) {
Add optional version to --json
2022-01-31 19:20:06 +00:00
usage(std::string("unsupported json version ") + parameter);
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
return this;
QPDFJob: convert trivial functions to config API
2022-01-24 00:46:20 +00:00
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
QPDFJob::Config*
Make QPDFArgParser accept const argv This makes it much more convention to use the initializeFromArgv functions since you can use string literals.
2022-02-01 18:37:31 +00:00
QPDFJob::Config::jsonKey(std::string const& parameter)
QPDFJob: convert trivial functions to config API
2022-01-24 00:46:20 +00:00
{
QPDFJob: move private members into Members
2022-01-26 19:56:24 +00:00
o.m->json_keys.insert(parameter);
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
return this;
QPDFJob: convert trivial functions to config API
2022-01-24 00:46:20 +00:00
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
QPDFJob::Config*
Make QPDFArgParser accept const argv This makes it much more convention to use the initializeFromArgv functions since you can use string literals.
2022-02-01 18:37:31 +00:00
QPDFJob::Config::jsonObject(std::string const& parameter)
QPDFJob: convert trivial functions to config API
2022-01-24 00:46:20 +00:00
{
QPDFJob: move private members into Members
2022-01-26 19:56:24 +00:00
o.m->json_objects.insert(parameter);
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
return this;
QPDFJob: convert trivial functions to config API
2022-01-24 00:46:20 +00:00
}
Implement JSON v2 output
2022-05-07 17:33:45 +00:00
QPDFJob::Config*
QPDFJob::Config::jsonStreamData(std::string const& parameter)
{
Major rework -- see long comments * Replace --create-from-json=file with --json-input, which causes the regular input to be treated as json. * Eliminate --to-json * In --json=2, bring back "objects" and eliminate "objectinfo". Stream data is never present. * In --json-output=2, write "qpdf-v2" with "objects" and include stream data.
2022-05-18 22:22:57 +00:00
o.m->json_stream_data_set = true;
Implement JSON v2 output
2022-05-07 17:33:45 +00:00
if (parameter == "none") {
o.m->json_stream_data = qpdf_sj_none;
} else if (parameter == "inline") {
o.m->json_stream_data = qpdf_sj_inline;
} else if (parameter == "file") {
o.m->json_stream_data = qpdf_sj_file;
} else {
usage("invalid json-streams option");
}
return this;
}
QPDFJob::Config*
QPDFJob::Config::jsonStreamPrefix(std::string const& parameter)
{
o.m->json_stream_prefix = parameter;
return this;
}
Add --to-json option
2022-05-07 21:17:27 +00:00
QPDFJob::Config*
Major rework -- see long comments * Replace --create-from-json=file with --json-input, which causes the regular input to be treated as json. * Eliminate --to-json * In --json=2, bring back "objects" and eliminate "objectinfo". Stream data is never present. * In --json-output=2, write "qpdf-v2" with "objects" and include stream data.
2022-05-18 22:22:57 +00:00
QPDFJob::Config::jsonInput()
Add --to-json option
2022-05-07 21:17:27 +00:00
{
Major rework -- see long comments * Replace --create-from-json=file with --json-input, which causes the regular input to be treated as json. * Eliminate --to-json * In --json=2, bring back "objects" and eliminate "objectinfo". Stream data is never present. * In --json-output=2, write "qpdf-v2" with "objects" and include stream data.
2022-05-18 22:22:57 +00:00
o.m->json_input = true;
Add --to-json option
2022-05-07 21:17:27 +00:00
return this;
}
Add --create-from-json and --update-from-json arguments Also add stubs for top-level QPDF methods (createFromJSON, updateFromJSON)
2022-05-08 17:42:16 +00:00
QPDFJob::Config*
Major rework -- see long comments * Replace --create-from-json=file with --json-input, which causes the regular input to be treated as json. * Eliminate --to-json * In --json=2, bring back "objects" and eliminate "objectinfo". Stream data is never present. * In --json-output=2, write "qpdf-v2" with "objects" and include stream data.
2022-05-18 22:22:57 +00:00
QPDFJob::Config::jsonOutput(std::string const& parameter)
Add --create-from-json and --update-from-json arguments Also add stubs for top-level QPDF methods (createFromJSON, updateFromJSON)
2022-05-08 17:42:16 +00:00
{
Change the output of --json to use "qpdf" instead of "objects"
2022-07-31 00:53:30 +00:00
o.m->json_output = true;
Simplify --json-output Now --json-output just changes defaults. Allow output file with --json.
2022-07-31 14:34:05 +00:00
json(parameter);
Major rework -- see long comments * Replace --create-from-json=file with --json-input, which causes the regular input to be treated as json. * Eliminate --to-json * In --json=2, bring back "objects" and eliminate "objectinfo". Stream data is never present. * In --json-output=2, write "qpdf-v2" with "objects" and include stream data.
2022-05-18 22:22:57 +00:00
if (!o.m->json_stream_data_set) {
Code tidy - reflow comments and strings
2023-05-27 17:19:52 +00:00
// No need to set json_stream_data_set -- that indicates explicit use of --json-stream-data.
Major rework -- see long comments * Replace --create-from-json=file with --json-input, which causes the regular input to be treated as json. * Eliminate --to-json * In --json=2, bring back "objects" and eliminate "objectinfo". Stream data is never present. * In --json-output=2, write "qpdf-v2" with "objects" and include stream data.
2022-05-18 22:22:57 +00:00
o.m->json_stream_data = qpdf_sj_inline;
}
Change default decode level to "none" with --json-output
2022-05-21 21:51:34 +00:00
if (!o.m->decode_level_set) {
o.m->decode_level = qpdf_dl_none;
}
Simplify --json-output Now --json-output just changes defaults. Allow output file with --json.
2022-07-31 14:34:05 +00:00
o.m->json_keys.insert("qpdf");
Add --create-from-json and --update-from-json arguments Also add stubs for top-level QPDF methods (createFromJSON, updateFromJSON)
2022-05-08 17:42:16 +00:00
return this;
}
QPDFJob::Config*
QPDFJob::Config::updateFromJson(std::string const& parameter)
{
o.m->update_from_json = parameter;
return this;
}
Add --test-json-schema command-line option
2022-05-06 21:29:22 +00:00
QPDFJob::Config*
QPDFJob::Config::testJsonSchema()
{
o.m->test_json_schema = true;
return this;
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
QPDFJob::Config*
Make QPDFArgParser accept const argv This makes it much more convention to use the initializeFromArgv functions since you can use string literals.
2022-02-01 18:37:31 +00:00
QPDFJob::Config::keepFilesOpen(std::string const& parameter)
QPDFJob: convert trivial functions to config API
2022-01-24 00:46:20 +00:00
{
QPDFJob: move private members into Members
2022-01-26 19:56:24 +00:00
o.m->keep_files_open_set = true;
Make QPDFArgParser accept const argv This makes it much more convention to use the initializeFromArgv functions since you can use string literals.
2022-02-01 18:37:31 +00:00
o.m->keep_files_open = (parameter == "y");
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
return this;
QPDFJob: convert trivial functions to config API
2022-01-24 00:46:20 +00:00
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
QPDFJob::Config*
Make QPDFArgParser accept const argv This makes it much more convention to use the initializeFromArgv functions since you can use string literals.
2022-02-01 18:37:31 +00:00
QPDFJob::Config::keepFilesOpenThreshold(std::string const& parameter)
QPDFJob: convert trivial functions to config API
2022-01-24 00:46:20 +00:00
{
Make QPDFArgParser accept const argv This makes it much more convention to use the initializeFromArgv functions since you can use string literals.
2022-02-01 18:37:31 +00:00
o.m->keep_files_open_threshold = QUtil::string_to_uint(parameter.c_str());
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
return this;
QPDFJob: convert trivial functions to config API
2022-01-24 00:46:20 +00:00
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
QPDFJob::Config*
QPDFJob: convert trivial functions to config API
2022-01-24 00:46:20 +00:00
QPDFJob::Config::keepInlineImages()
{
QPDFJob: move private members into Members
2022-01-26 19:56:24 +00:00
o.m->keep_inline_images = true;
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
return this;
QPDFJob: convert trivial functions to config API
2022-01-24 00:46:20 +00:00
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
QPDFJob::Config*
QPDFJob: convert trivial functions to config API
2022-01-24 00:46:20 +00:00
QPDFJob::Config::linearize()
{
QPDFJob: move private members into Members
2022-01-26 19:56:24 +00:00
o.m->linearize = true;
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
return this;
QPDFJob: convert trivial functions to config API
2022-01-24 00:46:20 +00:00
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
QPDFJob::Config*
Make QPDFArgParser accept const argv This makes it much more convention to use the initializeFromArgv functions since you can use string literals.
2022-02-01 18:37:31 +00:00
QPDFJob::Config::linearizePass1(std::string const& parameter)
QPDFJob: convert trivial functions to config API
2022-01-24 00:46:20 +00:00
{
QPDFJob: move private members into Members
2022-01-26 19:56:24 +00:00
o.m->linearize_pass1 = parameter;
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
return this;
QPDFJob: convert trivial functions to config API
2022-01-24 00:46:20 +00:00
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
QPDFJob::Config*
QPDFJob: convert trivial functions to config API
2022-01-24 00:46:20 +00:00
QPDFJob::Config::listAttachments()
{
QPDFJob: move private members into Members
2022-01-26 19:56:24 +00:00
o.m->list_attachments = true;
o.m->require_outfile = false;
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
return this;
QPDFJob: convert trivial functions to config API
2022-01-24 00:46:20 +00:00
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
QPDFJob::Config*
Make QPDFArgParser accept const argv This makes it much more convention to use the initializeFromArgv functions since you can use string literals.
2022-02-01 18:37:31 +00:00
QPDFJob::Config::minVersion(std::string const& parameter)
QPDFJob: convert trivial functions to config API
2022-01-24 00:46:20 +00:00
{
QPDFJob: move private members into Members
2022-01-26 19:56:24 +00:00
o.m->min_version = parameter;
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
return this;
QPDFJob: convert trivial functions to config API
2022-01-24 00:46:20 +00:00
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
QPDFJob::Config*
QPDFJob: convert trivial functions to config API
2022-01-24 00:46:20 +00:00
QPDFJob::Config::newlineBeforeEndstream()
{
QPDFJob: move private members into Members
2022-01-26 19:56:24 +00:00
o.m->newline_before_endstream = true;
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
return this;
QPDFJob: convert trivial functions to config API
2022-01-24 00:46:20 +00:00
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
QPDFJob::Config*
QPDFJob: convert trivial functions to config API
2022-01-24 00:46:20 +00:00
QPDFJob::Config::noOriginalObjectIds()
{
QPDFJob: move private members into Members
2022-01-26 19:56:24 +00:00
o.m->suppress_original_object_id = true;
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
return this;
QPDFJob: convert trivial functions to config API
2022-01-24 00:46:20 +00:00
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
QPDFJob::Config*
QPDFJob: convert trivial functions to config API
2022-01-24 00:46:20 +00:00
QPDFJob::Config::noWarn()
{
QPDFJob: move private members into Members
2022-01-26 19:56:24 +00:00
o.m->suppress_warnings = true;
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
return this;
QPDFJob: convert trivial functions to config API
2022-01-24 00:46:20 +00:00
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
QPDFJob::Config*
Make QPDFArgParser accept const argv This makes it much more convention to use the initializeFromArgv functions since you can use string literals.
2022-02-01 18:37:31 +00:00
QPDFJob::Config::normalizeContent(std::string const& parameter)
QPDFJob: convert trivial functions to config API
2022-01-24 00:46:20 +00:00
{
QPDFJob: move private members into Members
2022-01-26 19:56:24 +00:00
o.m->normalize_set = true;
Make QPDFArgParser accept const argv This makes it much more convention to use the initializeFromArgv functions since you can use string literals.
2022-02-01 18:37:31 +00:00
o.m->normalize = (parameter == "y");
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
return this;
QPDFJob: convert trivial functions to config API
2022-01-24 00:46:20 +00:00
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
QPDFJob::Config*
Make QPDFArgParser accept const argv This makes it much more convention to use the initializeFromArgv functions since you can use string literals.
2022-02-01 18:37:31 +00:00
QPDFJob::Config::oiMinArea(std::string const& parameter)
QPDFJob: convert trivial functions to config API
2022-01-24 00:46:20 +00:00
{
Make QPDFArgParser accept const argv This makes it much more convention to use the initializeFromArgv functions since you can use string literals.
2022-02-01 18:37:31 +00:00
o.m->oi_min_area = QUtil::string_to_uint(parameter.c_str());
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
return this;
QPDFJob: convert trivial functions to config API
2022-01-24 00:46:20 +00:00
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
QPDFJob::Config*
Make QPDFArgParser accept const argv This makes it much more convention to use the initializeFromArgv functions since you can use string literals.
2022-02-01 18:37:31 +00:00
QPDFJob::Config::oiMinHeight(std::string const& parameter)
QPDFJob: convert trivial functions to config API
2022-01-24 00:46:20 +00:00
{
Make QPDFArgParser accept const argv This makes it much more convention to use the initializeFromArgv functions since you can use string literals.
2022-02-01 18:37:31 +00:00
o.m->oi_min_height = QUtil::string_to_uint(parameter.c_str());
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
return this;
QPDFJob: convert trivial functions to config API
2022-01-24 00:46:20 +00:00
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
QPDFJob::Config*
Make QPDFArgParser accept const argv This makes it much more convention to use the initializeFromArgv functions since you can use string literals.
2022-02-01 18:37:31 +00:00
QPDFJob::Config::oiMinWidth(std::string const& parameter)
QPDFJob: convert trivial functions to config API
2022-01-24 00:46:20 +00:00
{
Make QPDFArgParser accept const argv This makes it much more convention to use the initializeFromArgv functions since you can use string literals.
2022-02-01 18:37:31 +00:00
o.m->oi_min_width = QUtil::string_to_uint(parameter.c_str());
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
return this;
QPDFJob: convert trivial functions to config API
2022-01-24 00:46:20 +00:00
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
QPDFJob::Config*
QPDFJob: convert trivial functions to config API
2022-01-24 00:46:20 +00:00
QPDFJob::Config::optimizeImages()
{
QPDFJob: move private members into Members
2022-01-26 19:56:24 +00:00
o.m->optimize_images = true;
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
return this;
QPDFJob: convert trivial functions to config API
2022-01-24 00:46:20 +00:00
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
QPDFJob::Config*
Make QPDFArgParser accept const argv This makes it much more convention to use the initializeFromArgv functions since you can use string literals.
2022-02-01 18:37:31 +00:00
QPDFJob::Config::password(std::string const& parameter)
QPDFJob: convert password in two tables
2022-01-25 16:14:43 +00:00
{
QPDFJob: move private members into Members
2022-01-26 19:56:24 +00:00
o.m->password = QUtil::make_shared_cstr(parameter);
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
return this;
QPDFJob: convert password in two tables
2022-01-25 16:14:43 +00:00
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
QPDFJob::Config*
QPDFJob: convert trivial functions to config API
2022-01-24 00:46:20 +00:00
QPDFJob::Config::passwordIsHexKey()
{
QPDFJob: move private members into Members
2022-01-26 19:56:24 +00:00
o.m->password_is_hex_key = true;
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
return this;
QPDFJob: convert trivial functions to config API
2022-01-24 00:46:20 +00:00
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
QPDFJob::Config*
QPDFJob: convert trivial functions to config API
2022-01-24 00:46:20 +00:00
QPDFJob::Config::preserveUnreferenced()
{
QPDFJob: move private members into Members
2022-01-26 19:56:24 +00:00
o.m->preserve_unreferenced_objects = true;
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
return this;
QPDFJob: convert trivial functions to config API
2022-01-24 00:46:20 +00:00
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
QPDFJob::Config*
QPDFJob: convert trivial functions to config API
2022-01-24 00:46:20 +00:00
QPDFJob::Config::preserveUnreferencedResources()
{
QPDFJob: move private members into Members
2022-01-26 19:56:24 +00:00
o.m->remove_unreferenced_page_resources = QPDFJob::re_no;
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
return this;
QPDFJob: convert trivial functions to config API
2022-01-24 00:46:20 +00:00
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
QPDFJob::Config*
QPDFJob: convert trivial functions to config API
2022-01-24 00:46:20 +00:00
QPDFJob::Config::progress()
{
QPDFJob: move private members into Members
2022-01-26 19:56:24 +00:00
o.m->progress = true;
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
return this;
QPDFJob: convert trivial functions to config API
2022-01-24 00:46:20 +00:00
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
QPDFJob::Config*
QPDFJob: convert trivial functions to config API
2022-01-24 00:46:20 +00:00
QPDFJob::Config::qdf()
{
QPDFJob: move private members into Members
2022-01-26 19:56:24 +00:00
o.m->qdf_mode = true;
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
return this;
QPDFJob: convert trivial functions to config API
2022-01-24 00:46:20 +00:00
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
QPDFJob::Config*
QPDFJob: convert trivial functions to config API
2022-01-24 00:46:20 +00:00
QPDFJob::Config::rawStreamData()
{
QPDFJob: move private members into Members
2022-01-26 19:56:24 +00:00
o.m->show_raw_stream_data = true;
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
return this;
QPDFJob: convert trivial functions to config API
2022-01-24 00:46:20 +00:00
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
QPDFJob::Config*
QPDFJob: convert trivial functions to config API
2022-01-24 00:46:20 +00:00
QPDFJob::Config::recompressFlate()
{
QPDFJob: move private members into Members
2022-01-26 19:56:24 +00:00
o.m->recompress_flate_set = true;
o.m->recompress_flate = true;
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
return this;
QPDFJob: convert trivial functions to config API
2022-01-24 00:46:20 +00:00
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
QPDFJob::Config*
Make QPDFArgParser accept const argv This makes it much more convention to use the initializeFromArgv functions since you can use string literals.
2022-02-01 18:37:31 +00:00
QPDFJob::Config::removeAttachment(std::string const& parameter)
QPDFJob: convert trivial functions to config API
2022-01-24 00:46:20 +00:00
{
QPDFJob: move private members into Members
2022-01-26 19:56:24 +00:00
o.m->attachments_to_remove.push_back(parameter);
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
return this;
QPDFJob: convert trivial functions to config API
2022-01-24 00:46:20 +00:00
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
QPDFJob::Config*
QPDFJob: convert trivial functions to config API
2022-01-24 00:46:20 +00:00
QPDFJob::Config::removePageLabels()
{
QPDFJob: move private members into Members
2022-01-26 19:56:24 +00:00
o.m->remove_page_labels = true;
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
return this;
QPDFJob: convert trivial functions to config API
2022-01-24 00:46:20 +00:00
}
Add --report-mem-usage option for debugging/testing
2022-08-31 17:51:58 +00:00
QPDFJob::Config*
Rename --report-mem-usage to --report-memory-usage Avd xcsv brvtns.
2022-09-01 20:40:06 +00:00
QPDFJob::Config::reportMemoryUsage()
Add --report-mem-usage option for debugging/testing
2022-08-31 17:51:58 +00:00
{
o.m->report_mem_usage = true;
return this;
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
QPDFJob::Config*
QPDFJob: convert trivial functions to config API
2022-01-24 00:46:20 +00:00
QPDFJob::Config::requiresPassword()
{
QPDFJob: move private members into Members
2022-01-26 19:56:24 +00:00
o.m->check_requires_password = true;
o.m->require_outfile = false;
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
return this;
Add stub for --remove-restrictions
2023-01-28 18:24:45 +00:00
}
QPDFJob::Config*
QPDFJob::Config::removeRestrictions()
{
o.m->remove_restrictions = true;
return this;
QPDFJob: convert trivial functions to config API
2022-01-24 00:46:20 +00:00
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
QPDFJob::Config*
Make QPDFArgParser accept const argv This makes it much more convention to use the initializeFromArgv functions since you can use string literals.
2022-02-01 18:37:31 +00:00
QPDFJob::Config::showAttachment(std::string const& parameter)
QPDFJob: convert trivial functions to config API
2022-01-24 00:46:20 +00:00
{
QPDFJob: move private members into Members
2022-01-26 19:56:24 +00:00
o.m->attachment_to_show = parameter;
o.m->require_outfile = false;
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
return this;
QPDFJob: convert trivial functions to config API
2022-01-24 00:46:20 +00:00
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
QPDFJob::Config*
QPDFJob: convert trivial functions to config API
2022-01-24 00:46:20 +00:00
QPDFJob::Config::showEncryption()
{
QPDFJob: move private members into Members
2022-01-26 19:56:24 +00:00
o.m->show_encryption = true;
o.m->require_outfile = false;
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
return this;
QPDFJob: convert trivial functions to config API
2022-01-24 00:46:20 +00:00
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
QPDFJob::Config*
QPDFJob: convert trivial functions to config API
2022-01-24 00:46:20 +00:00
QPDFJob::Config::showEncryptionKey()
{
QPDFJob: move private members into Members
2022-01-26 19:56:24 +00:00
o.m->show_encryption_key = true;
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
return this;
QPDFJob: convert trivial functions to config API
2022-01-24 00:46:20 +00:00
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
QPDFJob::Config*
QPDFJob: convert trivial functions to config API
2022-01-24 00:46:20 +00:00
QPDFJob::Config::showLinearization()
{
QPDFJob: move private members into Members
2022-01-26 19:56:24 +00:00
o.m->show_linearization = true;
o.m->require_outfile = false;
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
return this;
QPDFJob: convert trivial functions to config API
2022-01-24 00:46:20 +00:00
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
QPDFJob::Config*
QPDFJob: convert trivial functions to config API
2022-01-24 00:46:20 +00:00
QPDFJob::Config::showNpages()
{
QPDFJob: move private members into Members
2022-01-26 19:56:24 +00:00
o.m->show_npages = true;
o.m->require_outfile = false;
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
return this;
QPDFJob: convert trivial functions to config API
2022-01-24 00:46:20 +00:00
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
QPDFJob::Config*
QPDFJob: convert trivial functions to config API
2022-01-24 00:46:20 +00:00
QPDFJob::Config::showPages()
{
QPDFJob: move private members into Members
2022-01-26 19:56:24 +00:00
o.m->show_pages = true;
o.m->require_outfile = false;
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
return this;
QPDFJob: convert trivial functions to config API
2022-01-24 00:46:20 +00:00
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
QPDFJob::Config*
QPDFJob: convert trivial functions to config API
2022-01-24 00:46:20 +00:00
QPDFJob::Config::showXref()
{
QPDFJob: move private members into Members
2022-01-26 19:56:24 +00:00
o.m->show_xref = true;
o.m->require_outfile = false;
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
return this;
QPDFJob: convert trivial functions to config API
2022-01-24 00:46:20 +00:00
}
generate_auto_job: generate overloaded config decls for optional For optional parameter/choices, generate an overloaded config method that takes no arguments. This makes it possible to convert from a bare argument to one that takes an optional parameter without breaking binary compatibility.
2022-02-01 09:16:58 +00:00
QPDFJob::Config*
QPDFJob::Config::splitPages()
{
Make QPDFArgParser accept const argv This makes it much more convention to use the initializeFromArgv functions since you can use string literals.
2022-02-01 18:37:31 +00:00
return splitPages("");
generate_auto_job: generate overloaded config decls for optional For optional parameter/choices, generate an overloaded config method that takes no arguments. This makes it possible to convert from a bare argument to one that takes an optional parameter without breaking binary compatibility.
2022-02-01 09:16:58 +00:00
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
QPDFJob::Config*
Make QPDFArgParser accept const argv This makes it much more convention to use the initializeFromArgv functions since you can use string literals.
2022-02-01 18:37:31 +00:00
QPDFJob::Config::splitPages(std::string const& parameter)
QPDFJob: convert trivial functions to config API
2022-01-24 00:46:20 +00:00
{
Make QPDFArgParser accept const argv This makes it much more convention to use the initializeFromArgv functions since you can use string literals.
2022-02-01 18:37:31 +00:00
int n = (parameter.empty() ? 1 : QUtil::string_to_int(parameter.c_str()));
QPDFJob: move private members into Members
2022-01-26 19:56:24 +00:00
o.m->split_pages = n;
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
return this;
QPDFJob: convert trivial functions to config API
2022-01-24 00:46:20 +00:00
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
QPDFJob::Config*
QPDFJob: convert trivial functions to config API
2022-01-24 00:46:20 +00:00
QPDFJob::Config::staticAesIv()
{
QPDFJob: move private members into Members
2022-01-26 19:56:24 +00:00
o.m->static_aes_iv = true;
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
return this;
QPDFJob: convert trivial functions to config API
2022-01-24 00:46:20 +00:00
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
QPDFJob::Config*
QPDFJob: convert trivial functions to config API
2022-01-24 00:46:20 +00:00
QPDFJob::Config::staticId()
{
QPDFJob: move private members into Members
2022-01-26 19:56:24 +00:00
o.m->static_id = true;
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
return this;
QPDFJob: convert trivial functions to config API
2022-01-24 00:46:20 +00:00
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
QPDFJob::Config*
QPDFJob: convert trivial functions to config API
2022-01-24 00:46:20 +00:00
QPDFJob::Config::suppressPasswordRecovery()
{
QPDFJob: move private members into Members
2022-01-26 19:56:24 +00:00
o.m->suppress_password_recovery = true;
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
return this;
QPDFJob: convert trivial functions to config API
2022-01-24 00:46:20 +00:00
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
QPDFJob::Config*
QPDFJob: convert trivial functions to config API
2022-01-24 00:46:20 +00:00
QPDFJob::Config::suppressRecovery()
{
QPDFJob: move private members into Members
2022-01-26 19:56:24 +00:00
o.m->suppress_recovery = true;
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
return this;
QPDFJob: convert trivial functions to config API
2022-01-24 00:46:20 +00:00
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
QPDFJob::Config*
QPDFJob: convert trivial functions to config API
2022-01-24 00:46:20 +00:00
QPDFJob::Config::verbose()
QPDFJob: begin configuration API with verbose
2022-01-24 00:29:18 +00:00
{
o.m->verbose = true;
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
return this;
QPDFJob: begin configuration API with verbose
2022-01-24 00:29:18 +00:00
}
QPDFJob: convert trivial functions to config API
2022-01-24 00:46:20 +00:00
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
QPDFJob::Config*
QPDFJob: convert trivial functions to config API
2022-01-24 00:46:20 +00:00
QPDFJob::Config::warningExit0()
{
QPDFJob: move private members into Members
2022-01-26 19:56:24 +00:00
o.m->warnings_exit_zero = true;
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
return this;
QPDFJob: convert trivial functions to config API
2022-01-24 00:46:20 +00:00
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
QPDFJob::Config*
QPDFJob: convert trivial functions to config API
2022-01-24 00:46:20 +00:00
QPDFJob::Config::withImages()
{
QPDFJob: move private members into Members
2022-01-26 19:56:24 +00:00
o.m->show_page_images = true;
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
return this;
QPDFJob: convert trivial functions to config API
2022-01-24 00:46:20 +00:00
}
QPDFJob: convert a flag in other than the main table
2022-01-25 16:07:53 +00:00
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
QPDFJob::Config*
Make QPDFArgParser accept const argv This makes it much more convention to use the initializeFromArgv functions since you can use string literals.
2022-02-01 18:37:31 +00:00
QPDFJob::Config::passwordFile(std::string const& parameter)
QPDFJob: move more top-level trivial handlers into config
2022-01-26 00:21:46 +00:00
{
std::list<std::string> lines;
Programmatically apply new formatting to code Run this: for i in **/*.cc **/*.c **/*.h **/*.hh; do clang-format < $i >| $i.new && mv $i.new $i done
2022-04-02 21:14:10 +00:00
if (parameter == "-") {
QPDFJob: move more top-level trivial handlers into config
2022-01-26 00:21:46 +00:00
QTC::TC("qpdf", "QPDFJob_config password stdin");
lines = QUtil::read_lines_from_file(std::cin);
Programmatically apply new formatting to code Run this: for i in **/*.cc **/*.c **/*.h **/*.hh; do clang-format < $i >| $i.new && mv $i.new $i done
2022-04-02 21:14:10 +00:00
} else {
QPDFJob: move more top-level trivial handlers into config
2022-01-26 00:21:46 +00:00
QTC::TC("qpdf", "QPDFJob_config password file");
Make QPDFArgParser accept const argv This makes it much more convention to use the initializeFromArgv functions since you can use string literals.
2022-02-01 18:37:31 +00:00
lines = QUtil::read_lines_from_file(parameter.c_str());
QPDFJob: move more top-level trivial handlers into config
2022-01-26 00:21:46 +00:00
}
Programmatically apply new formatting to code Run this: for i in **/*.cc **/*.c **/*.h **/*.hh; do clang-format < $i >| $i.new && mv $i.new $i done
2022-04-02 21:14:10 +00:00
if (lines.size() >= 1) {
QPDFJob: move private members into Members
2022-01-26 19:56:24 +00:00
o.m->password = QUtil::make_shared_cstr(lines.front());
QPDFJob: move more top-level trivial handlers into config
2022-01-26 00:21:46 +00:00
Programmatically apply new formatting to code Run this: for i in **/*.cc **/*.c **/*.h **/*.hh; do clang-format < $i >| $i.new && mv $i.new $i done
2022-04-02 21:14:10 +00:00
if (lines.size() > 1) {
Use the default logger for other writes to stdout/stderr When there is no context for writing output or error messages, use the default logger.
2022-06-18 14:33:27 +00:00
*QPDFLogger::defaultLogger()->getError()
Rerun clang-format
2023-05-21 17:35:09 +00:00
<< this->o.m->message_prefix << ": WARNING: all but the first line of"
Use the default logger for other writes to stdout/stderr When there is no context for writing output or error messages, use the default logger.
2022-06-18 14:33:27 +00:00
<< " the password file are ignored\n";
QPDFJob: move more top-level trivial handlers into config
2022-01-26 00:21:46 +00:00
}
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
return this;
QPDFJob: move more top-level trivial handlers into config
2022-01-26 00:21:46 +00:00
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
QPDFJob::Config*
Make QPDFArgParser accept const argv This makes it much more convention to use the initializeFromArgv functions since you can use string literals.
2022-02-01 18:37:31 +00:00
QPDFJob::Config::passwordMode(std::string const& parameter)
QPDFJob: move more top-level trivial handlers into config
2022-01-26 00:21:46 +00:00
{
Programmatically apply new formatting to code Run this: for i in **/*.cc **/*.c **/*.h **/*.hh; do clang-format < $i >| $i.new && mv $i.new $i done
2022-04-02 21:14:10 +00:00
if (parameter == "bytes") {
QPDFJob: move private members into Members
2022-01-26 19:56:24 +00:00
o.m->password_mode = QPDFJob::pm_bytes;
Programmatically apply new formatting to code Run this: for i in **/*.cc **/*.c **/*.h **/*.hh; do clang-format < $i >| $i.new && mv $i.new $i done
2022-04-02 21:14:10 +00:00
} else if (parameter == "hex-bytes") {
QPDFJob: move private members into Members
2022-01-26 19:56:24 +00:00
o.m->password_mode = QPDFJob::pm_hex_bytes;
Programmatically apply new formatting to code Run this: for i in **/*.cc **/*.c **/*.h **/*.hh; do clang-format < $i >| $i.new && mv $i.new $i done
2022-04-02 21:14:10 +00:00
} else if (parameter == "unicode") {
QPDFJob: move private members into Members
2022-01-26 19:56:24 +00:00
o.m->password_mode = QPDFJob::pm_unicode;
Programmatically apply new formatting to code Run this: for i in **/*.cc **/*.c **/*.h **/*.hh; do clang-format < $i >| $i.new && mv $i.new $i done
2022-04-02 21:14:10 +00:00
} else if (parameter == "auto") {
QPDFJob: move private members into Members
2022-01-26 19:56:24 +00:00
o.m->password_mode = QPDFJob::pm_auto;
Programmatically apply new formatting to code Run this: for i in **/*.cc **/*.c **/*.h **/*.hh; do clang-format < $i >| $i.new && mv $i.new $i done
2022-04-02 21:14:10 +00:00
} else {
QPDFJob: move more top-level trivial handlers into config
2022-01-26 00:21:46 +00:00
usage("invalid password-mode option");
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
return this;
QPDFJob: move more top-level trivial handlers into config
2022-01-26 00:21:46 +00:00
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
QPDFJob::Config*
Make QPDFArgParser accept const argv This makes it much more convention to use the initializeFromArgv functions since you can use string literals.
2022-02-01 18:37:31 +00:00
QPDFJob::Config::streamData(std::string const& parameter)
QPDFJob: move more top-level trivial handlers into config
2022-01-26 00:21:46 +00:00
{
QPDFJob: move private members into Members
2022-01-26 19:56:24 +00:00
o.m->stream_data_set = true;
Programmatically apply new formatting to code Run this: for i in **/*.cc **/*.c **/*.h **/*.hh; do clang-format < $i >| $i.new && mv $i.new $i done
2022-04-02 21:14:10 +00:00
if (parameter == "compress") {
QPDFJob: move private members into Members
2022-01-26 19:56:24 +00:00
o.m->stream_data_mode = qpdf_s_compress;
Programmatically apply new formatting to code Run this: for i in **/*.cc **/*.c **/*.h **/*.hh; do clang-format < $i >| $i.new && mv $i.new $i done
2022-04-02 21:14:10 +00:00
} else if (parameter == "preserve") {
QPDFJob: move private members into Members
2022-01-26 19:56:24 +00:00
o.m->stream_data_mode = qpdf_s_preserve;
Programmatically apply new formatting to code Run this: for i in **/*.cc **/*.c **/*.h **/*.hh; do clang-format < $i >| $i.new && mv $i.new $i done
2022-04-02 21:14:10 +00:00
} else if (parameter == "uncompress") {
QPDFJob: move private members into Members
2022-01-26 19:56:24 +00:00
o.m->stream_data_mode = qpdf_s_uncompress;
Programmatically apply new formatting to code Run this: for i in **/*.cc **/*.c **/*.h **/*.hh; do clang-format < $i >| $i.new && mv $i.new $i done
2022-04-02 21:14:10 +00:00
} else {
QPDFJob: move more top-level trivial handlers into config
2022-01-26 00:21:46 +00:00
usage("invalid stream-data option");
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
return this;
QPDFJob: move more top-level trivial handlers into config
2022-01-26 00:21:46 +00:00
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
QPDFJob::Config*
Make QPDFArgParser accept const argv This makes it much more convention to use the initializeFromArgv functions since you can use string literals.
2022-02-01 18:37:31 +00:00
QPDFJob::Config::decodeLevel(std::string const& parameter)
QPDFJob: move more top-level trivial handlers into config
2022-01-26 00:21:46 +00:00
{
QPDFJob: move private members into Members
2022-01-26 19:56:24 +00:00
o.m->decode_level_set = true;
Programmatically apply new formatting to code Run this: for i in **/*.cc **/*.c **/*.h **/*.hh; do clang-format < $i >| $i.new && mv $i.new $i done
2022-04-02 21:14:10 +00:00
if (parameter == "none") {
QPDFJob: move private members into Members
2022-01-26 19:56:24 +00:00
o.m->decode_level = qpdf_dl_none;
Programmatically apply new formatting to code Run this: for i in **/*.cc **/*.c **/*.h **/*.hh; do clang-format < $i >| $i.new && mv $i.new $i done
2022-04-02 21:14:10 +00:00
} else if (parameter == "generalized") {
QPDFJob: move private members into Members
2022-01-26 19:56:24 +00:00
o.m->decode_level = qpdf_dl_generalized;
Programmatically apply new formatting to code Run this: for i in **/*.cc **/*.c **/*.h **/*.hh; do clang-format < $i >| $i.new && mv $i.new $i done
2022-04-02 21:14:10 +00:00
} else if (parameter == "specialized") {
QPDFJob: move private members into Members
2022-01-26 19:56:24 +00:00
o.m->decode_level = qpdf_dl_specialized;
Programmatically apply new formatting to code Run this: for i in **/*.cc **/*.c **/*.h **/*.hh; do clang-format < $i >| $i.new && mv $i.new $i done
2022-04-02 21:14:10 +00:00
} else if (parameter == "all") {
QPDFJob: move private members into Members
2022-01-26 19:56:24 +00:00
o.m->decode_level = qpdf_dl_all;
Programmatically apply new formatting to code Run this: for i in **/*.cc **/*.c **/*.h **/*.hh; do clang-format < $i >| $i.new && mv $i.new $i done
2022-04-02 21:14:10 +00:00
} else {
QPDFJob: move more top-level trivial handlers into config
2022-01-26 00:21:46 +00:00
usage("invalid option");
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
return this;
QPDFJob: move more top-level trivial handlers into config
2022-01-26 00:21:46 +00:00
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
QPDFJob::Config*
Make QPDFArgParser accept const argv This makes it much more convention to use the initializeFromArgv functions since you can use string literals.
2022-02-01 18:37:31 +00:00
QPDFJob::Config::objectStreams(std::string const& parameter)
QPDFJob: move more top-level trivial handlers into config
2022-01-26 00:21:46 +00:00
{
QPDFJob: move private members into Members
2022-01-26 19:56:24 +00:00
o.m->object_stream_set = true;
Programmatically apply new formatting to code Run this: for i in **/*.cc **/*.c **/*.h **/*.hh; do clang-format < $i >| $i.new && mv $i.new $i done
2022-04-02 21:14:10 +00:00
if (parameter == "disable") {
QPDFJob: move private members into Members
2022-01-26 19:56:24 +00:00
o.m->object_stream_mode = qpdf_o_disable;
Programmatically apply new formatting to code Run this: for i in **/*.cc **/*.c **/*.h **/*.hh; do clang-format < $i >| $i.new && mv $i.new $i done
2022-04-02 21:14:10 +00:00
} else if (parameter == "preserve") {
QPDFJob: move private members into Members
2022-01-26 19:56:24 +00:00
o.m->object_stream_mode = qpdf_o_preserve;
Programmatically apply new formatting to code Run this: for i in **/*.cc **/*.c **/*.h **/*.hh; do clang-format < $i >| $i.new && mv $i.new $i done
2022-04-02 21:14:10 +00:00
} else if (parameter == "generate") {
QPDFJob: move private members into Members
2022-01-26 19:56:24 +00:00
o.m->object_stream_mode = qpdf_o_generate;
Programmatically apply new formatting to code Run this: for i in **/*.cc **/*.c **/*.h **/*.hh; do clang-format < $i >| $i.new && mv $i.new $i done
2022-04-02 21:14:10 +00:00
} else {
QPDFJob: move more top-level trivial handlers into config
2022-01-26 00:21:46 +00:00
usage("invalid object stream mode");
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
return this;
QPDFJob: move more top-level trivial handlers into config
2022-01-26 00:21:46 +00:00
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
QPDFJob::Config*
Make QPDFArgParser accept const argv This makes it much more convention to use the initializeFromArgv functions since you can use string literals.
2022-02-01 18:37:31 +00:00
QPDFJob::Config::removeUnreferencedResources(std::string const& parameter)
QPDFJob: move more top-level trivial handlers into config
2022-01-26 00:21:46 +00:00
{
Programmatically apply new formatting to code Run this: for i in **/*.cc **/*.c **/*.h **/*.hh; do clang-format < $i >| $i.new && mv $i.new $i done
2022-04-02 21:14:10 +00:00
if (parameter == "auto") {
QPDFJob: move private members into Members
2022-01-26 19:56:24 +00:00
o.m->remove_unreferenced_page_resources = QPDFJob::re_auto;
Programmatically apply new formatting to code Run this: for i in **/*.cc **/*.c **/*.h **/*.hh; do clang-format < $i >| $i.new && mv $i.new $i done
2022-04-02 21:14:10 +00:00
} else if (parameter == "yes") {
QPDFJob: move private members into Members
2022-01-26 19:56:24 +00:00
o.m->remove_unreferenced_page_resources = QPDFJob::re_yes;
Programmatically apply new formatting to code Run this: for i in **/*.cc **/*.c **/*.h **/*.hh; do clang-format < $i >| $i.new && mv $i.new $i done
2022-04-02 21:14:10 +00:00
} else if (parameter == "no") {
QPDFJob: move private members into Members
2022-01-26 19:56:24 +00:00
o.m->remove_unreferenced_page_resources = QPDFJob::re_no;
Programmatically apply new formatting to code Run this: for i in **/*.cc **/*.c **/*.h **/*.hh; do clang-format < $i >| $i.new && mv $i.new $i done
2022-04-02 21:14:10 +00:00
} else {
QPDFJob: move more top-level trivial handlers into config
2022-01-26 00:21:46 +00:00
usage("invalid value for --remove-unreferenced-page-resources");
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
return this;
QPDFJob: move more top-level trivial handlers into config
2022-01-26 00:21:46 +00:00
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
QPDFJob::Config*
Make QPDFArgParser accept const argv This makes it much more convention to use the initializeFromArgv functions since you can use string literals.
2022-02-01 18:37:31 +00:00
QPDFJob::Config::showObject(std::string const& parameter)
QPDFJob: move more top-level trivial handlers into config
2022-01-26 00:21:46 +00:00
{
Rerun clang-format
2023-05-21 17:35:09 +00:00
QPDFJob::parse_object_id(parameter, o.m->show_trailer, o.m->show_obj, o.m->show_gen);
QPDFJob: move private members into Members
2022-01-26 19:56:24 +00:00
o.m->require_outfile = false;
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
return this;
QPDFJob: move more top-level trivial handlers into config
2022-01-26 00:21:46 +00:00
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
QPDFJob::Config*
Make QPDFArgParser accept const argv This makes it much more convention to use the initializeFromArgv functions since you can use string literals.
2022-02-01 18:37:31 +00:00
QPDFJob::Config::jobJsonFile(std::string const& parameter)
QPDFJob: move more top-level trivial handlers into config
2022-01-26 00:21:46 +00:00
{
Programmatically apply new formatting to code Run this: for i in **/*.cc **/*.c **/*.h **/*.hh; do clang-format < $i >| $i.new && mv $i.new $i done
2022-04-02 21:14:10 +00:00
try {
Rerun clang-format
2023-05-21 17:35:09 +00:00
o.initializeFromJson(QUtil::read_file_into_string(parameter.c_str()), true);
Programmatically apply new formatting to code Run this: for i in **/*.cc **/*.c **/*.h **/*.hh; do clang-format < $i >| $i.new && mv $i.new $i done
2022-04-02 21:14:10 +00:00
} catch (std::exception& e) {
QPDFJob: move more top-level trivial handlers into config
2022-01-26 00:21:46 +00:00
throw std::runtime_error(
Rerun clang-format
2023-05-21 17:35:09 +00:00
"error with job-json file " + std::string(parameter) + ": " + e.what() + "\nRun " +
this->o.m->message_prefix + " --job-json-help for information on the file format.");
QPDFJob: move more top-level trivial handlers into config
2022-01-26 00:21:46 +00:00
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
return this;
QPDFJob: move more top-level trivial handlers into config
2022-01-26 00:21:46 +00:00
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
QPDFJob::Config*
Make QPDFArgParser accept const argv This makes it much more convention to use the initializeFromArgv functions since you can use string literals.
2022-02-01 18:37:31 +00:00
QPDFJob::Config::rotate(std::string const& parameter)
QPDFJob: convert under/overlay and rotate
2022-01-26 14:38:34 +00:00
{
o.parseRotationParameter(parameter);
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
return this;
QPDFJob: convert under/overlay and rotate
2022-01-26 14:38:34 +00:00
}
QPDFJob: convert a flag in other than the main table
2022-01-25 16:07:53 +00:00
std::shared_ptr<QPDFJob::CopyAttConfig>
QPDFJob::Config::copyAttachmentsFrom()
{
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
return std::shared_ptr<CopyAttConfig>(new CopyAttConfig(this));
QPDFJob: convert a flag in other than the main table
2022-01-25 16:07:53 +00:00
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
QPDFJob::CopyAttConfig::CopyAttConfig(Config* c) :
QPDFJob: convert a flag in other than the main table
2022-01-25 16:07:53 +00:00
config(c)
{
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
QPDFJob::CopyAttConfig*
Make QPDFArgParser accept const argv This makes it much more convention to use the initializeFromArgv functions since you can use string literals.
2022-02-01 18:37:31 +00:00
QPDFJob::CopyAttConfig::file(std::string const& parameter)
QPDFJob: convert a flag in other than the main table
2022-01-25 16:07:53 +00:00
{
this->caf.path = parameter;
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
return this;
QPDFJob: convert a flag in other than the main table
2022-01-25 16:07:53 +00:00
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
QPDFJob::CopyAttConfig*
Make QPDFArgParser accept const argv This makes it much more convention to use the initializeFromArgv functions since you can use string literals.
2022-02-01 18:37:31 +00:00
QPDFJob::CopyAttConfig::prefix(std::string const& parameter)
QPDFJob: convert a flag in other than the main table
2022-01-25 16:07:53 +00:00
{
this->caf.prefix = parameter;
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
return this;
QPDFJob: convert a flag in other than the main table
2022-01-25 16:07:53 +00:00
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
QPDFJob::CopyAttConfig*
Make QPDFArgParser accept const argv This makes it much more convention to use the initializeFromArgv functions since you can use string literals.
2022-02-01 18:37:31 +00:00
QPDFJob::CopyAttConfig::password(std::string const& parameter)
QPDFJob: convert a flag in other than the main table
2022-01-25 16:07:53 +00:00
{
this->caf.password = parameter;
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
return this;
QPDFJob: convert a flag in other than the main table
2022-01-25 16:07:53 +00:00
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
QPDFJob::Config*
QPDFJob: use manually named end functions for Config classes Use named functions rather than just end() for clarity.
2022-01-26 22:02:30 +00:00
QPDFJob::CopyAttConfig::endCopyAttachmentsFrom()
QPDFJob: convert a flag in other than the main table
2022-01-25 16:07:53 +00:00
{
Programmatically apply new formatting to code Run this: for i in **/*.cc **/*.c **/*.h **/*.hh; do clang-format < $i >| $i.new && mv $i.new $i done
2022-04-02 21:14:10 +00:00
if (this->caf.path.empty()) {
Change filename or path to file in json and QPDFJob Use "file" consistently for specifying a file path. We use "filename" when adding attachments for a completely different purpose.
2022-01-31 18:07:19 +00:00
usage("copy attachments: no file specified");
QPDFJob: convert a flag in other than the main table
2022-01-25 16:07:53 +00:00
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
this->config->o.m->attachments_to_copy.push_back(this->caf);
QPDFJob: convert a flag in other than the main table
2022-01-25 16:07:53 +00:00
return this->config;
}
QPDFJob: convert AddAttachment handlers
2022-01-25 21:37:17 +00:00
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
QPDFJob::AttConfig::AttConfig(Config* c) :
QPDFJob: convert AddAttachment handlers
2022-01-25 21:37:17 +00:00
config(c)
{
}
std::shared_ptr<QPDFJob::AttConfig>
QPDFJob::Config::addAttachment()
{
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
return std::shared_ptr<AttConfig>(new AttConfig(this));
QPDFJob: convert AddAttachment handlers
2022-01-25 21:37:17 +00:00
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
QPDFJob::AttConfig*
Make QPDFArgParser accept const argv This makes it much more convention to use the initializeFromArgv functions since you can use string literals.
2022-02-01 18:37:31 +00:00
QPDFJob::AttConfig::file(std::string const& parameter)
QPDFJob: convert AddAttachment handlers
2022-01-25 21:37:17 +00:00
{
this->att.path = parameter;
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
return this;
QPDFJob: convert AddAttachment handlers
2022-01-25 21:37:17 +00:00
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
QPDFJob::AttConfig*
Make QPDFArgParser accept const argv This makes it much more convention to use the initializeFromArgv functions since you can use string literals.
2022-02-01 18:37:31 +00:00
QPDFJob::AttConfig::key(std::string const& parameter)
QPDFJob: convert AddAttachment handlers
2022-01-25 21:37:17 +00:00
{
this->att.key = parameter;
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
return this;
QPDFJob: convert AddAttachment handlers
2022-01-25 21:37:17 +00:00
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
QPDFJob::AttConfig*
Make QPDFArgParser accept const argv This makes it much more convention to use the initializeFromArgv functions since you can use string literals.
2022-02-01 18:37:31 +00:00
QPDFJob::AttConfig::filename(std::string const& parameter)
QPDFJob: convert AddAttachment handlers
2022-01-25 21:37:17 +00:00
{
this->att.filename = parameter;
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
return this;
QPDFJob: convert AddAttachment handlers
2022-01-25 21:37:17 +00:00
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
QPDFJob::AttConfig*
Make QPDFArgParser accept const argv This makes it much more convention to use the initializeFromArgv functions since you can use string literals.
2022-02-01 18:37:31 +00:00
QPDFJob::AttConfig::creationdate(std::string const& parameter)
QPDFJob: convert AddAttachment handlers
2022-01-25 21:37:17 +00:00
{
Programmatically apply new formatting to code Run this: for i in **/*.cc **/*.c **/*.h **/*.hh; do clang-format < $i >| $i.new && mv $i.new $i done
2022-04-02 21:14:10 +00:00
if (!QUtil::pdf_time_to_qpdf_time(parameter)) {
QPDFJob: move more top-level trivial handlers into config
2022-01-26 00:21:46 +00:00
usage(std::string(parameter) + " is not a valid PDF timestamp");
QPDFJob: convert AddAttachment handlers
2022-01-25 21:37:17 +00:00
}
this->att.creationdate = parameter;
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
return this;
QPDFJob: convert AddAttachment handlers
2022-01-25 21:37:17 +00:00
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
QPDFJob::AttConfig*
Make QPDFArgParser accept const argv This makes it much more convention to use the initializeFromArgv functions since you can use string literals.
2022-02-01 18:37:31 +00:00
QPDFJob::AttConfig::moddate(std::string const& parameter)
QPDFJob: convert AddAttachment handlers
2022-01-25 21:37:17 +00:00
{
Programmatically apply new formatting to code Run this: for i in **/*.cc **/*.c **/*.h **/*.hh; do clang-format < $i >| $i.new && mv $i.new $i done
2022-04-02 21:14:10 +00:00
if (!QUtil::pdf_time_to_qpdf_time(parameter)) {
QPDFJob: move more top-level trivial handlers into config
2022-01-26 00:21:46 +00:00
usage(std::string(parameter) + " is not a valid PDF timestamp");
QPDFJob: convert AddAttachment handlers
2022-01-25 21:37:17 +00:00
}
this->att.moddate = parameter;
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
return this;
QPDFJob: convert AddAttachment handlers
2022-01-25 21:37:17 +00:00
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
QPDFJob::AttConfig*
Make QPDFArgParser accept const argv This makes it much more convention to use the initializeFromArgv functions since you can use string literals.
2022-02-01 18:37:31 +00:00
QPDFJob::AttConfig::mimetype(std::string const& parameter)
QPDFJob: convert AddAttachment handlers
2022-01-25 21:37:17 +00:00
{
Programmatically apply new formatting to code Run this: for i in **/*.cc **/*.c **/*.h **/*.hh; do clang-format < $i >| $i.new && mv $i.new $i done
2022-04-02 21:14:10 +00:00
if (parameter.find('/') == std::string::npos) {
QPDFJob: move more top-level trivial handlers into config
2022-01-26 00:21:46 +00:00
usage("mime type should be specified as type/subtype");
QPDFJob: convert AddAttachment handlers
2022-01-25 21:37:17 +00:00
}
this->att.mimetype = parameter;
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
return this;
QPDFJob: convert AddAttachment handlers
2022-01-25 21:37:17 +00:00
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
QPDFJob::AttConfig*
Make QPDFArgParser accept const argv This makes it much more convention to use the initializeFromArgv functions since you can use string literals.
2022-02-01 18:37:31 +00:00
QPDFJob::AttConfig::description(std::string const& parameter)
QPDFJob: convert AddAttachment handlers
2022-01-25 21:37:17 +00:00
{
this->att.description = parameter;
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
return this;
QPDFJob: convert AddAttachment handlers
2022-01-25 21:37:17 +00:00
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
QPDFJob::AttConfig*
QPDFJob: convert AddAttachment handlers
2022-01-25 21:37:17 +00:00
QPDFJob::AttConfig::replace()
{
this->att.replace = true;
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
return this;
QPDFJob: convert AddAttachment handlers
2022-01-25 21:37:17 +00:00
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
QPDFJob::Config*
QPDFJob: use manually named end functions for Config classes Use named functions rather than just end() for clarity.
2022-01-26 22:02:30 +00:00
QPDFJob::AttConfig::endAddAttachment()
QPDFJob: convert AddAttachment handlers
2022-01-25 21:37:17 +00:00
{
Rerun clang-format
2023-05-21 17:35:09 +00:00
static std::string now = QUtil::qpdf_time_to_pdf_time(QUtil::get_current_qpdf_time());
Programmatically apply new formatting to code Run this: for i in **/*.cc **/*.c **/*.h **/*.hh; do clang-format < $i >| $i.new && mv $i.new $i done
2022-04-02 21:14:10 +00:00
if (this->att.path.empty()) {
Change filename or path to file in json and QPDFJob Use "file" consistently for specifying a file path. We use "filename" when adding attachments for a completely different purpose.
2022-01-31 18:07:19 +00:00
usage("add attachment: no file specified");
QPDFJob: convert AddAttachment handlers
2022-01-25 21:37:17 +00:00
}
std::string last_element = QUtil::path_basename(this->att.path);
Programmatically apply new formatting to code Run this: for i in **/*.cc **/*.c **/*.h **/*.hh; do clang-format < $i >| $i.new && mv $i.new $i done
2022-04-02 21:14:10 +00:00
if (last_element.empty()) {
Change filename or path to file in json and QPDFJob Use "file" consistently for specifying a file path. We use "filename" when adding attachments for a completely different purpose.
2022-01-31 18:07:19 +00:00
usage("file for --add-attachment may not be empty");
QPDFJob: convert AddAttachment handlers
2022-01-25 21:37:17 +00:00
}
Programmatically apply new formatting to code Run this: for i in **/*.cc **/*.c **/*.h **/*.hh; do clang-format < $i >| $i.new && mv $i.new $i done
2022-04-02 21:14:10 +00:00
if (this->att.filename.empty()) {
QPDFJob: convert AddAttachment handlers
2022-01-25 21:37:17 +00:00
this->att.filename = last_element;
}
Programmatically apply new formatting to code Run this: for i in **/*.cc **/*.c **/*.h **/*.hh; do clang-format < $i >| $i.new && mv $i.new $i done
2022-04-02 21:14:10 +00:00
if (this->att.key.empty()) {
QPDFJob: convert AddAttachment handlers
2022-01-25 21:37:17 +00:00
this->att.key = last_element;
}
Programmatically apply new formatting to code Run this: for i in **/*.cc **/*.c **/*.h **/*.hh; do clang-format < $i >| $i.new && mv $i.new $i done
2022-04-02 21:14:10 +00:00
if (this->att.creationdate.empty()) {
QPDFJob: convert AddAttachment handlers
2022-01-25 21:37:17 +00:00
this->att.creationdate = now;
}
Programmatically apply new formatting to code Run this: for i in **/*.cc **/*.c **/*.h **/*.hh; do clang-format < $i >| $i.new && mv $i.new $i done
2022-04-02 21:14:10 +00:00
if (this->att.moddate.empty()) {
QPDFJob: convert AddAttachment handlers
2022-01-25 21:37:17 +00:00
this->att.moddate = now;
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
this->config->o.m->attachments_to_add.push_back(this->att);
QPDFJob: convert AddAttachment handlers
2022-01-25 21:37:17 +00:00
return this->config;
}
QPDFJob: convert pages
2022-01-26 00:01:10 +00:00
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
QPDFJob::PagesConfig::PagesConfig(Config* c) :
QPDFJob: convert pages
2022-01-26 00:01:10 +00:00
config(c)
{
}
std::shared_ptr<QPDFJob::PagesConfig>
QPDFJob::Config::pages()
{
Programmatically apply new formatting to code Run this: for i in **/*.cc **/*.c **/*.h **/*.hh; do clang-format < $i >| $i.new && mv $i.new $i done
2022-04-02 21:14:10 +00:00
if (!o.m->page_specs.empty()) {
QPDFJob: eliminate most access to QPDFJob members from ArgParser All that's left now is input and output handling.
2022-01-26 18:39:22 +00:00
usage("--pages may only be specified one time");
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
return std::shared_ptr<PagesConfig>(new PagesConfig(this));
QPDFJob: convert pages
2022-01-26 00:01:10 +00:00
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
QPDFJob::Config*
QPDFJob: use manually named end functions for Config classes Use named functions rather than just end() for clarity.
2022-01-26 22:02:30 +00:00
QPDFJob::PagesConfig::endPages()
QPDFJob: convert pages
2022-01-26 00:01:10 +00:00
{
Support comma-separated numeric values with --collate (fixes #505)
2024-01-01 23:55:45 +00:00
auto n_specs = config->o.m->page_specs.size();
if (n_specs == 0) {
QPDFJob: move more top-level trivial handlers into config
2022-01-26 00:21:46 +00:00
usage("--pages: no page specifications given");
QPDFJob: convert pages
2022-01-26 00:01:10 +00:00
}
return this->config;
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
QPDFJob::PagesConfig*
Programmatically apply new formatting to code Run this: for i in **/*.cc **/*.c **/*.h **/*.hh; do clang-format < $i >| $i.new && mv $i.new $i done
2022-04-02 21:14:10 +00:00
QPDFJob::PagesConfig::pageSpec(
std::string const& filename, std::string const& range, char const* password)
QPDFJob: convert pages
2022-01-26 00:01:10 +00:00
{
Code tidy - Clang-Tidy rule modernize-use-emplace
2023-05-27 22:49:18 +00:00
this->config->o.m->page_specs.emplace_back(filename, password, range);
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
return this;
QPDFJob: convert pages
2022-01-26 00:01:10 +00:00
}
QPDFJob: convert under/overlay and rotate
2022-01-26 14:38:34 +00:00
Allow --file and --range with --pages Accept --file and --range as named parameters in additional to allowing positional arguments. This is in preparation for adding additional flags.
2024-01-09 16:41:18 +00:00
QPDFJob::PagesConfig*
QPDFJob::PagesConfig::file(std::string const& arg)
{
this->config->o.m->page_specs.emplace_back(arg, nullptr, "");
return this;
}
QPDFJob::PagesConfig*
QPDFJob::PagesConfig::range(std::string const& arg)
{
if (config->o.m->page_specs.empty()) {
QTC::TC("qpdf", "QPDFJob misplaced page range");
usage("in --range must follow a file name");
}
auto& last = config->o.m->page_specs.back();
if (!last.range.empty()) {
QTC::TC("qpdf", "QPDFJob duplicated range");
usage("--range already specified for this file");
}
last.range = arg;
return this;
}
QPDFJob::PagesConfig*
QPDFJob::PagesConfig::password(std::string const& arg)
{
if (config->o.m->page_specs.empty()) {
QTC::TC("qpdf", "QPDFJob misplaced pages password");
usage("in --pages, --password must follow a file name");
}
auto& last = config->o.m->page_specs.back();
if (last.password) {
QTC::TC("qpdf", "QPDFJob duplicated pages password");
usage("--password already specified for this file");
}
last.password = QUtil::make_shared_cstr(arg);
return this;
}
QPDFJob: convert under/overlay and rotate
2022-01-26 14:38:34 +00:00
std::shared_ptr<QPDFJob::UOConfig>
QPDFJob::Config::overlay()
{
Honor repeated overlay/underlay
2024-01-10 21:07:47 +00:00
o.m->overlay.emplace_back("overlay");
o.m->under_overlay = &o.m->overlay.back();
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
return std::shared_ptr<UOConfig>(new UOConfig(this));
QPDFJob: convert under/overlay and rotate
2022-01-26 14:38:34 +00:00
}
std::shared_ptr<QPDFJob::UOConfig>
QPDFJob::Config::underlay()
{
Honor repeated overlay/underlay
2024-01-10 21:07:47 +00:00
o.m->underlay.emplace_back("underlay");
o.m->under_overlay = &o.m->underlay.back();
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
return std::shared_ptr<UOConfig>(new UOConfig(this));
QPDFJob: convert under/overlay and rotate
2022-01-26 14:38:34 +00:00
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
QPDFJob::UOConfig::UOConfig(Config* c) :
QPDFJob: convert under/overlay and rotate
2022-01-26 14:38:34 +00:00
config(c)
{
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
QPDFJob::Config*
QPDFJob: use manually named end functions for Config classes Use named functions rather than just end() for clarity.
2022-01-26 22:02:30 +00:00
QPDFJob::UOConfig::endUnderlayOverlay()
QPDFJob: convert under/overlay and rotate
2022-01-26 14:38:34 +00:00
{
Programmatically apply new formatting to code Run this: for i in **/*.cc **/*.c **/*.h **/*.hh; do clang-format < $i >| $i.new && mv $i.new $i done
2022-04-02 21:14:10 +00:00
if (config->o.m->under_overlay->filename.empty()) {
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
usage(config->o.m->under_overlay->which + " file not specified");
QPDFJob: convert under/overlay and rotate
2022-01-26 14:38:34 +00:00
}
Code tidy : replace 0 with nullptr or true
2022-07-26 11:37:50 +00:00
config->o.m->under_overlay = nullptr;
QPDFJob: convert under/overlay and rotate
2022-01-26 14:38:34 +00:00
return this->config;
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
QPDFJob::UOConfig*
Make QPDFArgParser accept const argv This makes it much more convention to use the initializeFromArgv functions since you can use string literals.
2022-02-01 18:37:31 +00:00
QPDFJob::UOConfig::file(std::string const& parameter)
QPDFJob: convert under/overlay and rotate
2022-01-26 14:38:34 +00:00
{
Programmatically apply new formatting to code Run this: for i in **/*.cc **/*.c **/*.h **/*.hh; do clang-format < $i >| $i.new && mv $i.new $i done
2022-04-02 21:14:10 +00:00
if (!config->o.m->under_overlay->filename.empty()) {
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
usage(config->o.m->under_overlay->which + " file already specified");
Programmatically apply new formatting to code Run this: for i in **/*.cc **/*.c **/*.h **/*.hh; do clang-format < $i >| $i.new && mv $i.new $i done
2022-04-02 21:14:10 +00:00
} else {
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
config->o.m->under_overlay->filename = parameter;
QPDFJob: convert under/overlay and rotate
2022-01-26 14:38:34 +00:00
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
return this;
QPDFJob: convert under/overlay and rotate
2022-01-26 14:38:34 +00:00
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
QPDFJob::UOConfig*
Make QPDFArgParser accept const argv This makes it much more convention to use the initializeFromArgv functions since you can use string literals.
2022-02-01 18:37:31 +00:00
QPDFJob::UOConfig::to(std::string const& parameter)
QPDFJob: convert under/overlay and rotate
2022-01-26 14:38:34 +00:00
{
Make QPDFArgParser accept const argv This makes it much more convention to use the initializeFromArgv functions since you can use string literals.
2022-02-01 18:37:31 +00:00
config->o.parseNumrange(parameter.c_str(), 0);
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
config->o.m->under_overlay->to_nr = parameter;
return this;
QPDFJob: convert under/overlay and rotate
2022-01-26 14:38:34 +00:00
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
QPDFJob::UOConfig*
Make QPDFArgParser accept const argv This makes it much more convention to use the initializeFromArgv functions since you can use string literals.
2022-02-01 18:37:31 +00:00
QPDFJob::UOConfig::from(std::string const& parameter)
QPDFJob: convert under/overlay and rotate
2022-01-26 14:38:34 +00:00
{
Programmatically apply new formatting to code Run this: for i in **/*.cc **/*.c **/*.h **/*.hh; do clang-format < $i >| $i.new && mv $i.new $i done
2022-04-02 21:14:10 +00:00
if (!parameter.empty()) {
Make QPDFArgParser accept const argv This makes it much more convention to use the initializeFromArgv functions since you can use string literals.
2022-02-01 18:37:31 +00:00
config->o.parseNumrange(parameter.c_str(), 0);
QPDFJob: convert under/overlay and rotate
2022-01-26 14:38:34 +00:00
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
config->o.m->under_overlay->from_nr = parameter;
return this;
QPDFJob: convert under/overlay and rotate
2022-01-26 14:38:34 +00:00
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
QPDFJob::UOConfig*
Make QPDFArgParser accept const argv This makes it much more convention to use the initializeFromArgv functions since you can use string literals.
2022-02-01 18:37:31 +00:00
QPDFJob::UOConfig::repeat(std::string const& parameter)
QPDFJob: convert under/overlay and rotate
2022-01-26 14:38:34 +00:00
{
Programmatically apply new formatting to code Run this: for i in **/*.cc **/*.c **/*.h **/*.hh; do clang-format < $i >| $i.new && mv $i.new $i done
2022-04-02 21:14:10 +00:00
if (!parameter.empty()) {
Make QPDFArgParser accept const argv This makes it much more convention to use the initializeFromArgv functions since you can use string literals.
2022-02-01 18:37:31 +00:00
config->o.parseNumrange(parameter.c_str(), 0);
QPDFJob: convert under/overlay and rotate
2022-01-26 14:38:34 +00:00
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
config->o.m->under_overlay->repeat_nr = parameter;
return this;
QPDFJob: convert under/overlay and rotate
2022-01-26 14:38:34 +00:00
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
QPDFJob::UOConfig*
Make QPDFArgParser accept const argv This makes it much more convention to use the initializeFromArgv functions since you can use string literals.
2022-02-01 18:37:31 +00:00
QPDFJob::UOConfig::password(std::string const& parameter)
QPDFJob: convert under/overlay and rotate
2022-01-26 14:38:34 +00:00
{
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
config->o.m->under_overlay->password = QUtil::make_shared_cstr(parameter);
return this;
QPDFJob: convert under/overlay and rotate
2022-01-26 14:38:34 +00:00
}
QPDFJob: convert encryption handlers
2022-01-26 18:17:57 +00:00
std::shared_ptr<QPDFJob::EncConfig>
Programmatically apply new formatting to code Run this: for i in **/*.cc **/*.c **/*.h **/*.hh; do clang-format < $i >| $i.new && mv $i.new $i done
2022-04-02 21:14:10 +00:00
QPDFJob::Config::encrypt(
Rerun clang-format
2023-05-21 17:35:09 +00:00
int keylen, std::string const& user_password, std::string const& owner_password)
QPDFJob: convert encryption handlers
2022-01-26 18:17:57 +00:00
{
QPDFJob: move private members into Members
2022-01-26 19:56:24 +00:00
o.m->keylen = keylen;
Programmatically apply new formatting to code Run this: for i in **/*.cc **/*.c **/*.h **/*.hh; do clang-format < $i >| $i.new && mv $i.new $i done
2022-04-02 21:14:10 +00:00
if (keylen == 256) {
QPDFJob: move private members into Members
2022-01-26 19:56:24 +00:00
o.m->use_aes = true;
QPDFJob: convert encryption handlers
2022-01-26 18:17:57 +00:00
}
QPDFJob: move private members into Members
2022-01-26 19:56:24 +00:00
o.m->user_password = user_password;
o.m->owner_password = owner_password;
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
return std::shared_ptr<EncConfig>(new EncConfig(this));
QPDFJob: convert encryption handlers
2022-01-26 18:17:57 +00:00
}
Wiring for --set-page-labels: manual (non-bisectable commit) This commit contains only the manual changes. It is separated for clarity. This commit would not pass CI because it lacks the automated changes, which appear in the next commit.
2024-01-05 17:16:13 +00:00
QPDFJob::Config*
QPDFJob::Config::setPageLabels(const std::vector<std::string>& specs)
{
Implement --set-page-labels and supporting API (fixes #939)
2024-01-05 21:11:09 +00:00
static std::regex page_label_re(R"(^(z|r?\d+):([DaArR])?(?:/(\d+)?(?:/(.+)?)?)?$)");
o.m->page_label_specs.clear();
for (auto const& spec: specs) {
std::smatch match;
if (!std::regex_match(spec, match, page_label_re)) {
usage("page label spec must be n:[D|a|A|r|R][/start[/prefix]]");
}
auto first_page_str = match[1].str();
int first_page;
if (first_page_str == "z") {
first_page = -1;
} else if (first_page_str.at(0) == 'r') {
first_page = -QUtil::string_to_int(first_page_str.substr(1).c_str());
} else {
first_page = QUtil::string_to_int(first_page_str.c_str());
}
auto label_type_ch = match[2].matched ? match[2].str().at(0) : '\0';
qpdf_page_label_e label_type;
switch (label_type_ch) {
case 'D':
label_type = pl_digits;
break;
case 'a':
label_type = pl_alpha_lower;
break;
case 'A':
label_type = pl_alpha_upper;
break;
case 'r':
label_type = pl_roman_lower;
break;
case 'R':
label_type = pl_roman_upper;
break;
default:
label_type = pl_none;
}
auto start_num = match[3].matched ? QUtil::string_to_int(match[3].str().c_str()) : 1;
set page labels: detect start page < 1 (fixes #939)
2024-02-17 20:42:10 +00:00
if (start_num < 1) {
usage("starting page number must be >= 1");
}
Implement --set-page-labels and supporting API (fixes #939)
2024-01-05 21:11:09 +00:00
auto prefix = match[4].matched ? match[4].str() : "";
// We can't check ordering until we know how many pages there are, so that is delayed until
// near the end.
o.m->page_label_specs.emplace_back(first_page, label_type, start_num, prefix);
Wiring for --set-page-labels: manual (non-bisectable commit) This commit contains only the manual changes. It is separated for clarity. This commit would not pass CI because it lacks the automated changes, which appear in the next commit.
2024-01-05 17:16:13 +00:00
}
return this;
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
QPDFJob::EncConfig::EncConfig(Config* c) :
QPDFJob: convert encryption handlers
2022-01-26 18:17:57 +00:00
config(c)
{
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
QPDFJob::Config*
QPDFJob: use manually named end functions for Config classes Use named functions rather than just end() for clarity.
2022-01-26 22:02:30 +00:00
QPDFJob::EncConfig::endEncrypt()
QPDFJob: convert encryption handlers
2022-01-26 18:17:57 +00:00
{
Handle --encrypt -- without crashing
2023-12-23 01:09:31 +00:00
if (config->o.m->keylen == 0) {
usage("encryption key length is required");
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
config->o.m->encrypt = true;
config->o.m->decrypt = false;
config->o.m->copy_encryption = false;
QPDFJob: convert encryption handlers
2022-01-26 18:17:57 +00:00
return this->config;
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
QPDFJob::EncConfig*
QPDFJob: convert encryption handlers
2022-01-26 18:17:57 +00:00
QPDFJob::EncConfig::allowInsecure()
{
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
config->o.m->allow_insecure = true;
return this;
QPDFJob: convert encryption handlers
2022-01-26 18:17:57 +00:00
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
QPDFJob::EncConfig*
Make QPDFArgParser accept const argv This makes it much more convention to use the initializeFromArgv functions since you can use string literals.
2022-02-01 18:37:31 +00:00
QPDFJob::EncConfig::accessibility(std::string const& parameter)
QPDFJob: convert encryption handlers
2022-01-26 18:17:57 +00:00
{
Make QPDFArgParser accept const argv This makes it much more convention to use the initializeFromArgv functions since you can use string literals.
2022-02-01 18:37:31 +00:00
config->o.m->r3_accessibility = (parameter == "y");
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
return this;
QPDFJob: convert encryption handlers
2022-01-26 18:17:57 +00:00
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
QPDFJob::EncConfig*
Make QPDFArgParser accept const argv This makes it much more convention to use the initializeFromArgv functions since you can use string literals.
2022-02-01 18:37:31 +00:00
QPDFJob::EncConfig::extract(std::string const& parameter)
QPDFJob: convert encryption handlers
2022-01-26 18:17:57 +00:00
{
Programmatically apply new formatting to code Run this: for i in **/*.cc **/*.c **/*.h **/*.hh; do clang-format < $i >| $i.new && mv $i.new $i done
2022-04-02 21:14:10 +00:00
if (config->o.m->keylen == 40) {
Make QPDFArgParser accept const argv This makes it much more convention to use the initializeFromArgv functions since you can use string literals.
2022-02-01 18:37:31 +00:00
config->o.m->r2_extract = (parameter == "y");
Programmatically apply new formatting to code Run this: for i in **/*.cc **/*.c **/*.h **/*.hh; do clang-format < $i >| $i.new && mv $i.new $i done
2022-04-02 21:14:10 +00:00
} else {
Make QPDFArgParser accept const argv This makes it much more convention to use the initializeFromArgv functions since you can use string literals.
2022-02-01 18:37:31 +00:00
config->o.m->r3_extract = (parameter == "y");
QPDFJob: convert encryption handlers
2022-01-26 18:17:57 +00:00
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
return this;
QPDFJob: convert encryption handlers
2022-01-26 18:17:57 +00:00
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
QPDFJob::EncConfig*
Make QPDFArgParser accept const argv This makes it much more convention to use the initializeFromArgv functions since you can use string literals.
2022-02-01 18:37:31 +00:00
QPDFJob::EncConfig::print(std::string const& parameter)
QPDFJob: convert encryption handlers
2022-01-26 18:17:57 +00:00
{
Programmatically apply new formatting to code Run this: for i in **/*.cc **/*.c **/*.h **/*.hh; do clang-format < $i >| $i.new && mv $i.new $i done
2022-04-02 21:14:10 +00:00
if (config->o.m->keylen == 40) {
Make QPDFArgParser accept const argv This makes it much more convention to use the initializeFromArgv functions since you can use string literals.
2022-02-01 18:37:31 +00:00
config->o.m->r2_print = (parameter == "y");
Programmatically apply new formatting to code Run this: for i in **/*.cc **/*.c **/*.h **/*.hh; do clang-format < $i >| $i.new && mv $i.new $i done
2022-04-02 21:14:10 +00:00
} else if (parameter == "full") {
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
config->o.m->r3_print = qpdf_r3p_full;
Programmatically apply new formatting to code Run this: for i in **/*.cc **/*.c **/*.h **/*.hh; do clang-format < $i >| $i.new && mv $i.new $i done
2022-04-02 21:14:10 +00:00
} else if (parameter == "low") {
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
config->o.m->r3_print = qpdf_r3p_low;
Programmatically apply new formatting to code Run this: for i in **/*.cc **/*.c **/*.h **/*.hh; do clang-format < $i >| $i.new && mv $i.new $i done
2022-04-02 21:14:10 +00:00
} else if (parameter == "none") {
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
config->o.m->r3_print = qpdf_r3p_none;
Programmatically apply new formatting to code Run this: for i in **/*.cc **/*.c **/*.h **/*.hh; do clang-format < $i >| $i.new && mv $i.new $i done
2022-04-02 21:14:10 +00:00
} else {
QPDFJob: convert encryption handlers
2022-01-26 18:17:57 +00:00
usage("invalid print option");
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
return this;
QPDFJob: convert encryption handlers
2022-01-26 18:17:57 +00:00
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
QPDFJob::EncConfig*
Make QPDFArgParser accept const argv This makes it much more convention to use the initializeFromArgv functions since you can use string literals.
2022-02-01 18:37:31 +00:00
QPDFJob::EncConfig::modify(std::string const& parameter)
QPDFJob: convert encryption handlers
2022-01-26 18:17:57 +00:00
{
Programmatically apply new formatting to code Run this: for i in **/*.cc **/*.c **/*.h **/*.hh; do clang-format < $i >| $i.new && mv $i.new $i done
2022-04-02 21:14:10 +00:00
if (config->o.m->keylen == 40) {
Make QPDFArgParser accept const argv This makes it much more convention to use the initializeFromArgv functions since you can use string literals.
2022-02-01 18:37:31 +00:00
config->o.m->r2_modify = (parameter == "y");
Programmatically apply new formatting to code Run this: for i in **/*.cc **/*.c **/*.h **/*.hh; do clang-format < $i >| $i.new && mv $i.new $i done
2022-04-02 21:14:10 +00:00
} else if (parameter == "all") {
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
config->o.m->r3_assemble = true;
config->o.m->r3_annotate_and_form = true;
config->o.m->r3_form_filling = true;
config->o.m->r3_modify_other = true;
Programmatically apply new formatting to code Run this: for i in **/*.cc **/*.c **/*.h **/*.hh; do clang-format < $i >| $i.new && mv $i.new $i done
2022-04-02 21:14:10 +00:00
} else if (parameter == "annotate") {
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
config->o.m->r3_assemble = true;
config->o.m->r3_annotate_and_form = true;
config->o.m->r3_form_filling = true;
config->o.m->r3_modify_other = false;
Programmatically apply new formatting to code Run this: for i in **/*.cc **/*.c **/*.h **/*.hh; do clang-format < $i >| $i.new && mv $i.new $i done
2022-04-02 21:14:10 +00:00
} else if (parameter == "form") {
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
config->o.m->r3_assemble = true;
config->o.m->r3_annotate_and_form = false;
config->o.m->r3_form_filling = true;
config->o.m->r3_modify_other = false;
Programmatically apply new formatting to code Run this: for i in **/*.cc **/*.c **/*.h **/*.hh; do clang-format < $i >| $i.new && mv $i.new $i done
2022-04-02 21:14:10 +00:00
} else if (parameter == "assembly") {
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
config->o.m->r3_assemble = true;
config->o.m->r3_annotate_and_form = false;
config->o.m->r3_form_filling = false;
config->o.m->r3_modify_other = false;
Programmatically apply new formatting to code Run this: for i in **/*.cc **/*.c **/*.h **/*.hh; do clang-format < $i >| $i.new && mv $i.new $i done
2022-04-02 21:14:10 +00:00
} else if (parameter == "none") {
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
config->o.m->r3_assemble = false;
config->o.m->r3_annotate_and_form = false;
config->o.m->r3_form_filling = false;
config->o.m->r3_modify_other = false;
Programmatically apply new formatting to code Run this: for i in **/*.cc **/*.c **/*.h **/*.hh; do clang-format < $i >| $i.new && mv $i.new $i done
2022-04-02 21:14:10 +00:00
} else {
QPDFJob: convert encryption handlers
2022-01-26 18:17:57 +00:00
usage("invalid modify option");
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
return this;
QPDFJob: convert encryption handlers
2022-01-26 18:17:57 +00:00
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
QPDFJob::EncConfig*
QPDFJob: convert encryption handlers
2022-01-26 18:17:57 +00:00
QPDFJob::EncConfig::cleartextMetadata()
{
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
config->o.m->cleartext_metadata = true;
return this;
QPDFJob: convert encryption handlers
2022-01-26 18:17:57 +00:00
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
QPDFJob::EncConfig*
Make QPDFArgParser accept const argv This makes it much more convention to use the initializeFromArgv functions since you can use string literals.
2022-02-01 18:37:31 +00:00
QPDFJob::EncConfig::assemble(std::string const& parameter)
QPDFJob: convert encryption handlers
2022-01-26 18:17:57 +00:00
{
Make QPDFArgParser accept const argv This makes it much more convention to use the initializeFromArgv functions since you can use string literals.
2022-02-01 18:37:31 +00:00
config->o.m->r3_assemble = (parameter == "y");
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
return this;
QPDFJob: convert encryption handlers
2022-01-26 18:17:57 +00:00
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
QPDFJob::EncConfig*
Make QPDFArgParser accept const argv This makes it much more convention to use the initializeFromArgv functions since you can use string literals.
2022-02-01 18:37:31 +00:00
QPDFJob::EncConfig::annotate(std::string const& parameter)
QPDFJob: convert encryption handlers
2022-01-26 18:17:57 +00:00
{
Programmatically apply new formatting to code Run this: for i in **/*.cc **/*.c **/*.h **/*.hh; do clang-format < $i >| $i.new && mv $i.new $i done
2022-04-02 21:14:10 +00:00
if (config->o.m->keylen == 40) {
Make QPDFArgParser accept const argv This makes it much more convention to use the initializeFromArgv functions since you can use string literals.
2022-02-01 18:37:31 +00:00
config->o.m->r2_annotate = (parameter == "y");
Programmatically apply new formatting to code Run this: for i in **/*.cc **/*.c **/*.h **/*.hh; do clang-format < $i >| $i.new && mv $i.new $i done
2022-04-02 21:14:10 +00:00
} else {
Make QPDFArgParser accept const argv This makes it much more convention to use the initializeFromArgv functions since you can use string literals.
2022-02-01 18:37:31 +00:00
config->o.m->r3_annotate_and_form = (parameter == "y");
QPDFJob: convert encryption handlers
2022-01-26 18:17:57 +00:00
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
return this;
QPDFJob: convert encryption handlers
2022-01-26 18:17:57 +00:00
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
QPDFJob::EncConfig*
Make QPDFArgParser accept const argv This makes it much more convention to use the initializeFromArgv functions since you can use string literals.
2022-02-01 18:37:31 +00:00
QPDFJob::EncConfig::form(std::string const& parameter)
QPDFJob: convert encryption handlers
2022-01-26 18:17:57 +00:00
{
Make QPDFArgParser accept const argv This makes it much more convention to use the initializeFromArgv functions since you can use string literals.
2022-02-01 18:37:31 +00:00
config->o.m->r3_form_filling = (parameter == "y");
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
return this;
QPDFJob: convert encryption handlers
2022-01-26 18:17:57 +00:00
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
QPDFJob::EncConfig*
Make QPDFArgParser accept const argv This makes it much more convention to use the initializeFromArgv functions since you can use string literals.
2022-02-01 18:37:31 +00:00
QPDFJob::EncConfig::modifyOther(std::string const& parameter)
QPDFJob: convert encryption handlers
2022-01-26 18:17:57 +00:00
{
Make QPDFArgParser accept const argv This makes it much more convention to use the initializeFromArgv functions since you can use string literals.
2022-02-01 18:37:31 +00:00
config->o.m->r3_modify_other = (parameter == "y");
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
return this;
QPDFJob: convert encryption handlers
2022-01-26 18:17:57 +00:00
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
QPDFJob::EncConfig*
Make QPDFArgParser accept const argv This makes it much more convention to use the initializeFromArgv functions since you can use string literals.
2022-02-01 18:37:31 +00:00
QPDFJob::EncConfig::useAes(std::string const& parameter)
QPDFJob: convert encryption handlers
2022-01-26 18:17:57 +00:00
{
Make QPDFArgParser accept const argv This makes it much more convention to use the initializeFromArgv functions since you can use string literals.
2022-02-01 18:37:31 +00:00
config->o.m->use_aes = (parameter == "y");
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
return this;
QPDFJob: convert encryption handlers
2022-01-26 18:17:57 +00:00
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
QPDFJob::EncConfig*
QPDFJob: convert encryption handlers
2022-01-26 18:17:57 +00:00
QPDFJob::EncConfig::forceV4()
{
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
config->o.m->force_V4 = true;
return this;
QPDFJob: convert encryption handlers
2022-01-26 18:17:57 +00:00
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
QPDFJob::EncConfig*
QPDFJob: convert encryption handlers
2022-01-26 18:17:57 +00:00
QPDFJob::EncConfig::forceR5()
{
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
config->o.m->force_R5 = true;
return this;
QPDFJob: convert encryption handlers
2022-01-26 18:17:57 +00:00
}
Wiring for --set-page-labels: manual (non-bisectable commit) This commit contains only the manual changes. It is separated for clarity. This commit would not pass CI because it lacks the automated changes, which appear in the next commit.
2024-01-05 17:16:13 +00:00
QPDFJob::PageLabelsConfig::PageLabelsConfig(Config* c) :
config(c)
{
}
QPDFJob::Config*
QPDFJob::PageLabelsConfig::endSetPageLabels()
{
return this->config;
}
Copy Permalink