octoleo/qpdf
2
1
Fork 0
mirror of https://github.com/qpdf/qpdf.git synced 2024-11-08 22:31:09 +00:00
Code Issues Releases Wiki Activity
1921e44ca7
qpdf/libqpdf/QPDFJob_config.cc

Ignoring revisions in .git-blame-ignore-revs. Click here to bypass and see the normal blame view.

1216 lines
27 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
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>
QPDFJob: convert trivial functions to config API
2022-01-24 00:46:20 +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);
QPDFJob: move input/output handling into config
2022-01-26 18:56:13 +00:00
} else {
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) {
QPDFJob: move input/output handling into config
2022-01-26 18:56:13 +00:00
// Various places in QPDFJob.cc know that the empty string for infile means empty. We set it
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
// to something other than a null pointer as an indication that some input source has been
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
// specified. This approach means that passing "" as the argument to inputFile in job JSON,
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
// 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("");
QPDFJob: move input/output handling into config
2022-01-26 18:56:13 +00:00
} else {
usage("empty input can't be used since 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*
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);
QPDFJob: move input/output handling into config
2022-01-26 18:56:13 +00:00
} else {
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;
QPDFJob: move input/output handling into config
2022-01-26 18:56:13 +00:00
} else {
usage("replace-input can't be used since 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: 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;
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
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;
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
} 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;
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
} else if (parameter != "all") {
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;
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
} else {
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) {
// No need to set json_stream_data_set -- that indicates explicit use of --json-stream-data.
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;
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
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);
} else {
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
}
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
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()
<< this->o.m->message_prefix << ": WARNING: all but the first line of"
<< " 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
{
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
if (parameter == "bytes") {
QPDFJob: move private members into Members
2022-01-26 19:56:24 +00:00
o.m->password_mode = QPDFJob::pm_bytes;
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
} 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;
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
} 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;
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
} 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;
QPDFJob: move more top-level trivial handlers into config
2022-01-26 00:21:46 +00:00
} else {
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;
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
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;
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
} 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;
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
} 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;
QPDFJob: move more top-level trivial handlers into config
2022-01-26 00:21:46 +00:00
} else {
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;
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
if (parameter == "none") {
QPDFJob: move private members into Members
2022-01-26 19:56:24 +00:00
o.m->decode_level = qpdf_dl_none;
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
} 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;
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
} 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;
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
} 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;
QPDFJob: move more top-level trivial handlers into config
2022-01-26 00:21:46 +00:00
} else {
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;
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
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;
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
} 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;
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
} 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;
QPDFJob: move more top-level trivial handlers into config
2022-01-26 00:21:46 +00:00
} else {
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
{
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
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;
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
} 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;
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
} 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;
QPDFJob: move more top-level trivial handlers into config
2022-01-26 00:21:46 +00:00
} else {
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
{
QPDFJob: move private members into Members
2022-01-26 19:56:24 +00:00
QPDFJob::parse_object_id(parameter, o.m->show_trailer, o.m->show_obj, o.m->show_gen);
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
{
try {
Add new procedure QUtil::read_file_into_string
2023-03-06 14:41:43 +00:00
o.initializeFromJson(QUtil::read_file_into_string(parameter.c_str()), true);
QPDFJob: move more top-level trivial handlers into config
2022-01-26 00:21:46 +00:00
} catch (std::exception& e) {
throw std::runtime_error(
Fix typo in error message
2022-01-29 17:53:35 +00:00
"error with job-json file " + std::string(parameter) + ": " + e.what() + "\nRun " +
Fix typo in error message
2022-04-10 19:02:56 +00:00
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
{
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
{
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
{
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
{
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
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
{
static std::string now = QUtil::qpdf_time_to_pdf_time(QUtil::get_current_qpdf_time());
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);
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
}
if (this->att.filename.empty()) {
this->att.filename = last_element;
}
if (this->att.key.empty()) {
this->att.key = last_element;
}
if (this->att.creationdate.empty()) {
this->att.creationdate = now;
}
if (this->att.moddate.empty()) {
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()
{
QPDFJob: move private members into Members
2022-01-26 19:56:24 +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
}
Support comma-separated numeric values with --collate (fixes #505)
2024-01-01 23:55:45 +00:00
auto n_collate = config->o.m->collate.size();
if (!(n_collate == 0 || n_collate == 1 || n_collate == n_specs)) {
usage("--pages: if --collate has more than one value, it must have one value per page "
"specification");
}
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*
QPDFJob: convert pages
2022-01-26 00:01:10 +00:00
QPDFJob::PagesConfig::pageSpec(
std::string const& filename, std::string const& range, char const* password)
{
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
std::shared_ptr<QPDFJob::UOConfig>
QPDFJob::Config::overlay()
{
QPDFJob: move private members into Members
2022-01-26 19:56:24 +00:00
o.m->under_overlay = &o.m->overlay;
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()
{
QPDFJob: move private members into Members
2022-01-26 19:56:24 +00:00
o.m->under_overlay = &o.m->underlay;
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
{
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
if (config->o.m->under_overlay->filename.empty()) {
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
{
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
if (!config->o.m->under_overlay->filename.empty()) {
usage(config->o.m->under_overlay->which + " file already specified");
QPDFJob: convert under/overlay and rotate
2022-01-26 14:38:34 +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
{
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
if (!parameter.empty()) {
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
{
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
if (!parameter.empty()) {
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>
QPDFJob::Config::encrypt(
int keylen, std::string const& user_password, std::string const& owner_password)
{
QPDFJob: move private members into Members
2022-01-26 19:56:24 +00:00
o.m->keylen = keylen;
QPDFJob: convert encryption handlers
2022-01-26 18:17:57 +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
}
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
{
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
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");
QPDFJob: convert encryption handlers
2022-01-26 18:17:57 +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
{
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
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");
} 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;
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
} 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;
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
} 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;
QPDFJob: convert encryption handlers
2022-01-26 18:17:57 +00:00
} else {
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
{
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
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");
} 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;
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
} 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;
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
} 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;
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
} 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;
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
} 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;
QPDFJob: convert encryption handlers
2022-01-26 18:17:57 +00:00
} else {
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
{
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
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");
QPDFJob: convert encryption handlers
2022-01-26 18:17:57 +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
}
Copy Permalink