octoleo/qpdf
2
1
Fork 0
mirror of https://github.com/qpdf/qpdf.git synced 2024-11-18 02:25:08 +00:00
Code Issues Releases Wiki Activity
8b4afa428e
qpdf/libqpdf/QPDFJob_config.cc

1196 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>
Programmatically apply new formatting to code Run this: for i in **/*.cc **/*.c **/*.h **/*.hh; do clang-format < $i >| $i.new && mv $i.new $i done
2022-04-02 21:14:10 +00:00
#include <qpdf/QUtil.hh>
QPDFJob: begin configuration API with verbose
2022-01-24 00:29:18 +00:00
QPDFJob: add checkConfiguration to Config
2022-01-29 14:01:20 +00:00
void
QPDFJob::Config::checkConfiguration()
{
o.checkConfiguration();
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
QPDFJob::Config*
Make QPDFArgParser accept const argv This makes it much more convention to use the initializeFromArgv functions since you can use string literals.
2022-02-01 18:37:31 +00:00
QPDFJob::Config::inputFile(std::string const& filename)
QPDFJob: move input/output handling into config
2022-01-26 18:56:13 +00:00
{
Programmatically apply new formatting to code Run this: for i in **/*.cc **/*.c **/*.h **/*.hh; do clang-format < $i >| $i.new && mv $i.new $i done
2022-04-02 21:14:10 +00:00
if (o.m->infilename == 0) {
QPDFJob: move private members into Members
2022-01-26 19:56:24 +00:00
o.m->infilename = QUtil::make_shared_cstr(filename);
Programmatically apply new formatting to code Run this: for i in **/*.cc **/*.c **/*.h **/*.hh; do clang-format < $i >| $i.new && mv $i.new $i done
2022-04-02 21:14:10 +00:00
} else {
QPDFJob: move input/output handling into config
2022-01-26 18:56:13 +00:00
usage("input file has already been given");
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
return this;
QPDFJob: move input/output handling into config
2022-01-26 18:56:13 +00:00
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
QPDFJob::Config*
QPDFJob: move input/output handling into config
2022-01-26 18:56:13 +00:00
QPDFJob::Config::emptyInput()
{
Programmatically apply new formatting to code Run this: for i in **/*.cc **/*.c **/*.h **/*.hh; do clang-format < $i >| $i.new && mv $i.new $i done
2022-04-02 21:14:10 +00:00
if (o.m->infilename == 0) {
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
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
// infile means empty. We set it to something other than a
// null pointer as an indication that some input source has
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
// been specified. This approach means that passing "" as
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
// the argument to inputFile in job JSON, or equivalently
// using "" as a positional command-line argument would be the
// same as --empty. This probably isn't worth blocking or
// coding around.
QPDFJob: move private members into Members
2022-01-26 19:56:24 +00:00
o.m->infilename = QUtil::make_shared_cstr("");
Programmatically apply new formatting to code Run this: for i in **/*.cc **/*.c **/*.h **/*.hh; do clang-format < $i >| $i.new && mv $i.new $i done
2022-04-02 21:14:10 +00:00
} else {
QPDFJob: move input/output handling into config
2022-01-26 18:56:13 +00:00
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
{
Programmatically apply new formatting to code Run this: for i in **/*.cc **/*.c **/*.h **/*.hh; do clang-format < $i >| $i.new && mv $i.new $i done
2022-04-02 21:14:10 +00:00
if ((o.m->outfilename == 0) && (!o.m->replace_input)) {
QPDFJob: move private members into Members
2022-01-26 19:56:24 +00:00
o.m->outfilename = QUtil::make_shared_cstr(filename);
Programmatically apply new formatting to code Run this: for i in **/*.cc **/*.c **/*.h **/*.hh; do clang-format < $i >| $i.new && mv $i.new $i done
2022-04-02 21:14:10 +00:00
} else {
QPDFJob: move input/output handling into config
2022-01-26 18:56:13 +00:00
usage("output file has already been given");
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
return this;
QPDFJob: move input/output handling into config
2022-01-26 18:56:13 +00:00
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
QPDFJob::Config*
QPDFJob: move input/output handling into config
2022-01-26 18:56:13 +00:00
QPDFJob::Config::replaceInput()
{
Programmatically apply new formatting to code Run this: for i in **/*.cc **/*.c **/*.h **/*.hh; do clang-format < $i >| $i.new && mv $i.new $i done
2022-04-02 21:14:10 +00:00
if ((o.m->outfilename == 0) && (!o.m->replace_input)) {
QPDFJob: move private members into Members
2022-01-26 19:56:24 +00:00
o.m->replace_input = true;
Programmatically apply new formatting to code Run this: for i in **/*.cc **/*.c **/*.h **/*.hh; do clang-format < $i >| $i.new && mv $i.new $i done
2022-04-02 21:14:10 +00:00
} else {
QPDFJob: move input/output handling into config
2022-01-26 18:56:13 +00:00
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
{
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
auto n = (parameter.empty() ? 1 : QUtil::string_to_uint(parameter.c_str()));
QPDFJob: move private members into Members
2022-01-26 19:56:24 +00:00
o.m->collate = QIntC::to_size(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*
Make QPDFArgParser accept const argv This makes it much more convention to use the initializeFromArgv functions since you can use string literals.
2022-02-01 18:37:31 +00:00
QPDFJob::Config::compressStreams(std::string const& parameter)
QPDFJob: convert trivial functions to config API
2022-01-24 00:46:20 +00:00
{
QPDFJob: move private members into Members
2022-01-26 19:56:24 +00:00
o.m->compress_streams_set = true;
Make QPDFArgParser accept const argv This makes it much more convention to use the initializeFromArgv functions since you can use string literals.
2022-02-01 18:37:31 +00:00
o.m->compress_streams = (parameter == "y");
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
return this;
QPDFJob: convert trivial functions to config API
2022-01-24 00:46:20 +00:00
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
QPDFJob::Config*
Make QPDFArgParser accept const argv This makes it much more convention to use the initializeFromArgv functions since you can use string literals.
2022-02-01 18:37:31 +00:00
QPDFJob::Config::compressionLevel(std::string const& parameter)
QPDFJob: convert trivial functions to config API
2022-01-24 00:46:20 +00:00
{
Make QPDFArgParser accept const argv This makes it much more convention to use the initializeFromArgv functions since you can use string literals.
2022-02-01 18:37:31 +00:00
o.m->compression_level = QUtil::string_to_int(parameter.c_str());
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
return this;
QPDFJob: convert trivial functions to config API
2022-01-24 00:46:20 +00:00
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
QPDFJob::Config*
Make QPDFArgParser accept const argv This makes it much more convention to use the initializeFromArgv functions since you can use string literals.
2022-02-01 18:37:31 +00:00
QPDFJob::Config::copyEncryption(std::string const& parameter)
QPDFJob: convert trivial functions to config API
2022-01-24 00:46:20 +00:00
{
QPDFJob: move private members into Members
2022-01-26 19:56:24 +00:00
o.m->encryption_file = parameter;
o.m->copy_encryption = true;
o.m->encrypt = false;
o.m->decrypt = false;
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
return this;
QPDFJob: convert trivial functions to config API
2022-01-24 00:46:20 +00:00
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
QPDFJob::Config*
QPDFJob: convert trivial functions to config API
2022-01-24 00:46:20 +00:00
QPDFJob::Config::decrypt()
{
QPDFJob: move private members into Members
2022-01-26 19:56:24 +00:00
o.m->decrypt = true;
o.m->encrypt = false;
o.m->copy_encryption = false;
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
return this;
QPDFJob: convert trivial functions to config API
2022-01-24 00:46:20 +00:00
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
QPDFJob::Config*
QPDFJob: convert trivial functions to config API
2022-01-24 00:46:20 +00:00
QPDFJob::Config::deterministicId()
{
QPDFJob: move private members into Members
2022-01-26 19:56:24 +00:00
o.m->deterministic_id = true;
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
return this;
QPDFJob: convert trivial functions to config API
2022-01-24 00:46:20 +00:00
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
QPDFJob::Config*
Make QPDFArgParser accept const argv This makes it much more convention to use the initializeFromArgv functions since you can use string literals.
2022-02-01 18:37:31 +00:00
QPDFJob::Config::encryptionFilePassword(std::string const& parameter)
QPDFJob: convert trivial functions to config API
2022-01-24 00:46:20 +00:00
{
QPDFJob: move private members into Members
2022-01-26 19:56:24 +00:00
o.m->encryption_file_password = QUtil::make_shared_cstr(parameter);
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
return this;
QPDFJob: convert trivial functions to config API
2022-01-24 00:46:20 +00:00
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
QPDFJob::Config*
QPDFJob: convert trivial functions to config API
2022-01-24 00:46:20 +00:00
QPDFJob::Config::externalizeInlineImages()
{
QPDFJob: move private members into Members
2022-01-26 19:56:24 +00:00
o.m->externalize_inline_images = true;
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
return this;
QPDFJob: convert trivial functions to config API
2022-01-24 00:46:20 +00:00
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
QPDFJob::Config*
QPDFJob: convert trivial functions to config API
2022-01-24 00:46:20 +00:00
QPDFJob::Config::filteredStreamData()
{
QPDFJob: move private members into Members
2022-01-26 19:56:24 +00:00
o.m->show_filtered_stream_data = true;
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
return this;
QPDFJob: convert trivial functions to config API
2022-01-24 00:46:20 +00:00
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
QPDFJob::Config*
Make QPDFArgParser accept const argv This makes it much more convention to use the initializeFromArgv functions since you can use string literals.
2022-02-01 18:37:31 +00:00
QPDFJob::Config::flattenAnnotations(std::string const& parameter)
QPDFJob: convert trivial functions to config API
2022-01-24 00:46:20 +00:00
{
QPDFJob: move private members into Members
2022-01-26 19:56:24 +00:00
o.m->flatten_annotations = true;
Programmatically apply new formatting to code Run this: for i in **/*.cc **/*.c **/*.h **/*.hh; do clang-format < $i >| $i.new && mv $i.new $i done
2022-04-02 21:14:10 +00:00
if (parameter == "screen") {
QPDFJob: move private members into Members
2022-01-26 19:56:24 +00:00
o.m->flatten_annotations_forbidden |= an_no_view;
Programmatically apply new formatting to code Run this: for i in **/*.cc **/*.c **/*.h **/*.hh; do clang-format < $i >| $i.new && mv $i.new $i done
2022-04-02 21:14:10 +00:00
} else if (parameter == "print") {
QPDFJob: move private members into Members
2022-01-26 19:56:24 +00:00
o.m->flatten_annotations_required |= an_print;
Programmatically apply new formatting to code Run this: for i in **/*.cc **/*.c **/*.h **/*.hh; do clang-format < $i >| $i.new && mv $i.new $i done
2022-04-02 21:14:10 +00:00
} else if (parameter != "all") {
Make QPDFArgParser accept const argv This makes it much more convention to use the initializeFromArgv functions since you can use string literals.
2022-02-01 18:37:31 +00:00
usage("invalid flatten-annotations option");
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
return this;
QPDFJob: convert trivial functions to config API
2022-01-24 00:46:20 +00:00
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
QPDFJob::Config*
QPDFJob: convert trivial functions to config API
2022-01-24 00:46:20 +00:00
QPDFJob::Config::flattenRotation()
{
QPDFJob: move private members into Members
2022-01-26 19:56:24 +00:00
o.m->flatten_rotation = true;
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
return this;
QPDFJob: convert trivial functions to config API
2022-01-24 00:46:20 +00:00
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
QPDFJob::Config*
Make QPDFArgParser accept const argv This makes it much more convention to use the initializeFromArgv functions since you can use string literals.
2022-02-01 18:37:31 +00:00
QPDFJob::Config::forceVersion(std::string const& parameter)
QPDFJob: convert trivial functions to config API
2022-01-24 00:46:20 +00:00
{
QPDFJob: move private members into Members
2022-01-26 19:56:24 +00:00
o.m->force_version = parameter;
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
return this;
QPDFJob: convert trivial functions to config API
2022-01-24 00:46:20 +00:00
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
QPDFJob::Config*
QPDFJob: convert trivial functions to config API
2022-01-24 00:46:20 +00:00
QPDFJob::Config::generateAppearances()
{
QPDFJob: move private members into Members
2022-01-26 19:56:24 +00:00
o.m->generate_appearances = true;
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
return this;
QPDFJob: convert trivial functions to config API
2022-01-24 00:46:20 +00:00
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
QPDFJob::Config*
QPDFJob: convert trivial functions to config API
2022-01-24 00:46:20 +00:00
QPDFJob::Config::ignoreXrefStreams()
{
QPDFJob: move private members into Members
2022-01-26 19:56:24 +00:00
o.m->ignore_xref_streams = true;
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
return this;
QPDFJob: convert trivial functions to config API
2022-01-24 00:46:20 +00:00
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
QPDFJob::Config*
Make QPDFArgParser accept const argv This makes it much more convention to use the initializeFromArgv functions since you can use string literals.
2022-02-01 18:37:31 +00:00
QPDFJob::Config::iiMinBytes(std::string const& parameter)
QPDFJob: convert trivial functions to config API
2022-01-24 00:46:20 +00:00
{
Make QPDFArgParser accept const argv This makes it much more convention to use the initializeFromArgv functions since you can use string literals.
2022-02-01 18:37:31 +00:00
o.m->ii_min_bytes = QUtil::string_to_uint(parameter.c_str());
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
return this;
QPDFJob: convert trivial functions to config API
2022-01-24 00:46:20 +00:00
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
QPDFJob::Config*
QPDFJob: convert trivial functions to config API
2022-01-24 00:46:20 +00:00
QPDFJob::Config::isEncrypted()
{
QPDFJob: move private members into Members
2022-01-26 19:56:24 +00:00
o.m->check_is_encrypted = true;
o.m->require_outfile = false;
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
return this;
QPDFJob: convert trivial functions to config API
2022-01-24 00:46:20 +00:00
}
generate_auto_job: generate overloaded config decls for optional For optional parameter/choices, generate an overloaded config method that takes no arguments. This makes it possible to convert from a bare argument to one that takes an optional parameter without breaking binary compatibility.
2022-02-01 09:16:58 +00:00
QPDFJob::Config*
QPDFJob::Config::json()
{
Make QPDFArgParser accept const argv This makes it much more convention to use the initializeFromArgv functions since you can use string literals.
2022-02-01 18:37:31 +00:00
return json("");
generate_auto_job: generate overloaded config decls for optional For optional parameter/choices, generate an overloaded config method that takes no arguments. This makes it possible to convert from a bare argument to one that takes an optional parameter without breaking binary compatibility.
2022-02-01 09:16:58 +00:00
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
QPDFJob::Config*
Make QPDFArgParser accept const argv This makes it much more convention to use the initializeFromArgv functions since you can use string literals.
2022-02-01 18:37:31 +00:00
QPDFJob::Config::json(std::string const& parameter)
QPDFJob: convert trivial functions to config API
2022-01-24 00:46:20 +00:00
{
Change default --json from 1 to latest
2022-04-16 16:57:33 +00:00
if (parameter.empty() || (parameter == "latest")) {
Prepare code for JSON v2 Update getJSON() methods and calls to them
2022-05-07 11:53:45 +00:00
o.m->json_version = JSON::LATEST;
Programmatically apply new formatting to code Run this: for i in **/*.cc **/*.c **/*.h **/*.hh; do clang-format < $i >| $i.new && mv $i.new $i done
2022-04-02 21:14:10 +00:00
} else {
Make QPDFArgParser accept const argv This makes it much more convention to use the initializeFromArgv functions since you can use string literals.
2022-02-01 18:37:31 +00:00
o.m->json_version = QUtil::string_to_int(parameter.c_str());
}
Prepare code for JSON v2 Update getJSON() methods and calls to them
2022-05-07 11:53:45 +00:00
if ((o.m->json_version < 1) || (o.m->json_version > JSON::LATEST)) {
Add optional version to --json
2022-01-31 19:20:06 +00:00
usage(std::string("unsupported json version ") + parameter);
}
QPDFJob: move private members into Members
2022-01-26 19:56:24 +00:00
o.m->require_outfile = false;
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
return this;
QPDFJob: 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
{
Make version default to latest for --json-output (like --json)
2022-05-20 11:25:54 +00:00
if (parameter.empty() || (parameter == "latest")) {
o.m->json_output = JSON::LATEST;
} else {
o.m->json_output = QUtil::string_to_int(parameter.c_str());
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
}
Make version default to latest for --json-output (like --json)
2022-05-20 11:25:54 +00:00
if ((o.m->json_output < 2) || (o.m->json_output > JSON::LATEST)) {
usage(std::string("unsupported json output version ") + 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;
}
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
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you 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;
QPDFJob: convert trivial functions to config API
2022-01-24 00:46:20 +00:00
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
QPDFJob::Config*
Make QPDFArgParser accept const argv This makes it much more convention to use the initializeFromArgv functions since you can use string literals.
2022-02-01 18:37:31 +00:00
QPDFJob::Config::showAttachment(std::string const& parameter)
QPDFJob: convert trivial functions to config API
2022-01-24 00:46:20 +00:00
{
QPDFJob: move private members into Members
2022-01-26 19:56:24 +00:00
o.m->attachment_to_show = parameter;
o.m->require_outfile = false;
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
return this;
QPDFJob: convert trivial functions to config API
2022-01-24 00:46:20 +00:00
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
QPDFJob::Config*
QPDFJob: convert trivial functions to config API
2022-01-24 00:46:20 +00:00
QPDFJob::Config::showEncryption()
{
QPDFJob: move private members into Members
2022-01-26 19:56:24 +00:00
o.m->show_encryption = true;
o.m->require_outfile = false;
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
return this;
QPDFJob: convert trivial functions to config API
2022-01-24 00:46:20 +00:00
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
QPDFJob::Config*
QPDFJob: convert trivial functions to config API
2022-01-24 00:46:20 +00:00
QPDFJob::Config::showEncryptionKey()
{
QPDFJob: move private members into Members
2022-01-26 19:56:24 +00:00
o.m->show_encryption_key = true;
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
return this;
QPDFJob: convert trivial functions to config API
2022-01-24 00:46:20 +00:00
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
QPDFJob::Config*
QPDFJob: convert trivial functions to config API
2022-01-24 00:46:20 +00:00
QPDFJob::Config::showLinearization()
{
QPDFJob: move private members into Members
2022-01-26 19:56:24 +00:00
o.m->show_linearization = true;
o.m->require_outfile = false;
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
return this;
QPDFJob: convert trivial functions to config API
2022-01-24 00:46:20 +00:00
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
QPDFJob::Config*
QPDFJob: convert trivial functions to config API
2022-01-24 00:46:20 +00:00
QPDFJob::Config::showNpages()
{
QPDFJob: move private members into Members
2022-01-26 19:56:24 +00:00
o.m->show_npages = true;
o.m->require_outfile = false;
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
return this;
QPDFJob: convert trivial functions to config API
2022-01-24 00:46:20 +00:00
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
QPDFJob::Config*
QPDFJob: convert trivial functions to config API
2022-01-24 00:46:20 +00:00
QPDFJob::Config::showPages()
{
QPDFJob: move private members into Members
2022-01-26 19:56:24 +00:00
o.m->show_pages = true;
o.m->require_outfile = false;
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
return this;
QPDFJob: convert trivial functions to config API
2022-01-24 00:46:20 +00:00
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
QPDFJob::Config*
QPDFJob: convert trivial functions to config API
2022-01-24 00:46:20 +00:00
QPDFJob::Config::showXref()
{
QPDFJob: move private members into Members
2022-01-26 19:56:24 +00:00
o.m->show_xref = true;
o.m->require_outfile = false;
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
return this;
QPDFJob: convert trivial functions to config API
2022-01-24 00:46:20 +00:00
}
generate_auto_job: generate overloaded config decls for optional For optional parameter/choices, generate an overloaded config method that takes no arguments. This makes it possible to convert from a bare argument to one that takes an optional parameter without breaking binary compatibility.
2022-02-01 09:16:58 +00:00
QPDFJob::Config*
QPDFJob::Config::splitPages()
{
Make QPDFArgParser accept const argv This makes it much more convention to use the initializeFromArgv functions since you can use string literals.
2022-02-01 18:37:31 +00:00
return splitPages("");
generate_auto_job: generate overloaded config decls for optional For optional parameter/choices, generate an overloaded config method that takes no arguments. This makes it possible to convert from a bare argument to one that takes an optional parameter without breaking binary compatibility.
2022-02-01 09:16:58 +00:00
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
QPDFJob::Config*
Make QPDFArgParser accept const argv This makes it much more convention to use the initializeFromArgv functions since you can use string literals.
2022-02-01 18:37:31 +00:00
QPDFJob::Config::splitPages(std::string const& parameter)
QPDFJob: convert trivial functions to config API
2022-01-24 00:46:20 +00:00
{
Make QPDFArgParser accept const argv This makes it much more convention to use the initializeFromArgv functions since you can use string literals.
2022-02-01 18:37:31 +00:00
int n = (parameter.empty() ? 1 : QUtil::string_to_int(parameter.c_str()));
QPDFJob: move private members into Members
2022-01-26 19:56:24 +00:00
o.m->split_pages = n;
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
return this;
QPDFJob: convert trivial functions to config API
2022-01-24 00:46:20 +00:00
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
QPDFJob::Config*
QPDFJob: convert trivial functions to config API
2022-01-24 00:46:20 +00:00
QPDFJob::Config::staticAesIv()
{
QPDFJob: move private members into Members
2022-01-26 19:56:24 +00:00
o.m->static_aes_iv = true;
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
return this;
QPDFJob: convert trivial functions to config API
2022-01-24 00:46:20 +00:00
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
QPDFJob::Config*
QPDFJob: convert trivial functions to config API
2022-01-24 00:46:20 +00:00
QPDFJob::Config::staticId()
{
QPDFJob: move private members into Members
2022-01-26 19:56:24 +00:00
o.m->static_id = true;
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
return this;
QPDFJob: convert trivial functions to config API
2022-01-24 00:46:20 +00:00
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
QPDFJob::Config*
QPDFJob: convert trivial functions to config API
2022-01-24 00:46:20 +00:00
QPDFJob::Config::suppressPasswordRecovery()
{
QPDFJob: move private members into Members
2022-01-26 19:56:24 +00:00
o.m->suppress_password_recovery = true;
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
return this;
QPDFJob: convert trivial functions to config API
2022-01-24 00:46:20 +00:00
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
QPDFJob::Config*
QPDFJob: convert trivial functions to config API
2022-01-24 00:46:20 +00:00
QPDFJob::Config::suppressRecovery()
{
QPDFJob: move private members into Members
2022-01-26 19:56:24 +00:00
o.m->suppress_recovery = true;
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
return this;
QPDFJob: convert trivial functions to config API
2022-01-24 00:46:20 +00:00
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
QPDFJob::Config*
QPDFJob: convert trivial functions to config API
2022-01-24 00:46:20 +00:00
QPDFJob::Config::verbose()
QPDFJob: begin configuration API with verbose
2022-01-24 00:29:18 +00:00
{
o.m->verbose = true;
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
return this;
QPDFJob: begin configuration API with verbose
2022-01-24 00:29:18 +00:00
}
QPDFJob: convert trivial functions to config API
2022-01-24 00:46:20 +00:00
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
QPDFJob::Config*
QPDFJob: convert trivial functions to config API
2022-01-24 00:46:20 +00:00
QPDFJob::Config::warningExit0()
{
QPDFJob: move private members into Members
2022-01-26 19:56:24 +00:00
o.m->warnings_exit_zero = true;
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
return this;
QPDFJob: convert trivial functions to config API
2022-01-24 00:46:20 +00:00
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
QPDFJob::Config*
QPDFJob: convert trivial functions to config API
2022-01-24 00:46:20 +00:00
QPDFJob::Config::withImages()
{
QPDFJob: move private members into Members
2022-01-26 19:56:24 +00:00
o.m->show_page_images = true;
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
return this;
QPDFJob: convert trivial functions to config API
2022-01-24 00:46:20 +00:00
}
QPDFJob: convert a flag in other than the main table
2022-01-25 16:07:53 +00:00
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
QPDFJob::Config*
Make QPDFArgParser accept const argv This makes it much more convention to use the initializeFromArgv functions since you can use string literals.
2022-02-01 18:37:31 +00:00
QPDFJob::Config::passwordFile(std::string const& parameter)
QPDFJob: move more top-level trivial handlers into config
2022-01-26 00:21:46 +00:00
{
std::list<std::string> lines;
Programmatically apply new formatting to code Run this: for i in **/*.cc **/*.c **/*.h **/*.hh; do clang-format < $i >| $i.new && mv $i.new $i done
2022-04-02 21:14:10 +00:00
if (parameter == "-") {
QPDFJob: move more top-level trivial handlers into config
2022-01-26 00:21:46 +00:00
QTC::TC("qpdf", "QPDFJob_config password stdin");
lines = QUtil::read_lines_from_file(std::cin);
Programmatically apply new formatting to code Run this: for i in **/*.cc **/*.c **/*.h **/*.hh; do clang-format < $i >| $i.new && mv $i.new $i done
2022-04-02 21:14:10 +00:00
} else {
QPDFJob: move more top-level trivial handlers into config
2022-01-26 00:21:46 +00:00
QTC::TC("qpdf", "QPDFJob_config password file");
Make QPDFArgParser accept const argv This makes it much more convention to use the initializeFromArgv functions since you can use string literals.
2022-02-01 18:37:31 +00:00
lines = QUtil::read_lines_from_file(parameter.c_str());
QPDFJob: move more top-level trivial handlers into config
2022-01-26 00:21:46 +00:00
}
Programmatically apply new formatting to code Run this: for i in **/*.cc **/*.c **/*.h **/*.hh; do clang-format < $i >| $i.new && mv $i.new $i done
2022-04-02 21:14:10 +00:00
if (lines.size() >= 1) {
QPDFJob: move private members into Members
2022-01-26 19:56:24 +00:00
o.m->password = QUtil::make_shared_cstr(lines.front());
QPDFJob: move more top-level trivial handlers into config
2022-01-26 00:21:46 +00:00
Programmatically apply new formatting to code Run this: for i in **/*.cc **/*.c **/*.h **/*.hh; do clang-format < $i >| $i.new && mv $i.new $i done
2022-04-02 21:14:10 +00:00
if (lines.size() > 1) {
Use the default logger for other writes to stdout/stderr When there is no context for writing output or error messages, use the default logger.
2022-06-18 14:33:27 +00:00
*QPDFLogger::defaultLogger()->getError()
<< 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
{
Programmatically apply new formatting to code Run this: for i in **/*.cc **/*.c **/*.h **/*.hh; do clang-format < $i >| $i.new && mv $i.new $i done
2022-04-02 21:14:10 +00:00
if (parameter == "bytes") {
QPDFJob: move private members into Members
2022-01-26 19:56:24 +00:00
o.m->password_mode = QPDFJob::pm_bytes;
Programmatically apply new formatting to code Run this: for i in **/*.cc **/*.c **/*.h **/*.hh; do clang-format < $i >| $i.new && mv $i.new $i done
2022-04-02 21:14:10 +00:00
} else if (parameter == "hex-bytes") {
QPDFJob: move private members into Members
2022-01-26 19:56:24 +00:00
o.m->password_mode = QPDFJob::pm_hex_bytes;
Programmatically apply new formatting to code Run this: for i in **/*.cc **/*.c **/*.h **/*.hh; do clang-format < $i >| $i.new && mv $i.new $i done
2022-04-02 21:14:10 +00:00
} else if (parameter == "unicode") {
QPDFJob: move private members into Members
2022-01-26 19:56:24 +00:00
o.m->password_mode = QPDFJob::pm_unicode;
Programmatically apply new formatting to code Run this: for i in **/*.cc **/*.c **/*.h **/*.hh; do clang-format < $i >| $i.new && mv $i.new $i done
2022-04-02 21:14:10 +00:00
} else if (parameter == "auto") {
QPDFJob: move private members into Members
2022-01-26 19:56:24 +00:00
o.m->password_mode = QPDFJob::pm_auto;
Programmatically apply new formatting to code Run this: for i in **/*.cc **/*.c **/*.h **/*.hh; do clang-format < $i >| $i.new && mv $i.new $i done
2022-04-02 21:14:10 +00:00
} else {
QPDFJob: move more top-level trivial handlers into config
2022-01-26 00:21:46 +00:00
usage("invalid password-mode option");
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
return this;
QPDFJob: move more top-level trivial handlers into config
2022-01-26 00:21:46 +00:00
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
QPDFJob::Config*
Make QPDFArgParser accept const argv This makes it much more convention to use the initializeFromArgv functions since you can use string literals.
2022-02-01 18:37:31 +00:00
QPDFJob::Config::streamData(std::string const& parameter)
QPDFJob: move more top-level trivial handlers into config
2022-01-26 00:21:46 +00:00
{
QPDFJob: move private members into Members
2022-01-26 19:56:24 +00:00
o.m->stream_data_set = true;
Programmatically apply new formatting to code Run this: for i in **/*.cc **/*.c **/*.h **/*.hh; do clang-format < $i >| $i.new && mv $i.new $i done
2022-04-02 21:14:10 +00:00
if (parameter == "compress") {
QPDFJob: move private members into Members
2022-01-26 19:56:24 +00:00
o.m->stream_data_mode = qpdf_s_compress;
Programmatically apply new formatting to code Run this: for i in **/*.cc **/*.c **/*.h **/*.hh; do clang-format < $i >| $i.new && mv $i.new $i done
2022-04-02 21:14:10 +00:00
} else if (parameter == "preserve") {
QPDFJob: move private members into Members
2022-01-26 19:56:24 +00:00
o.m->stream_data_mode = qpdf_s_preserve;
Programmatically apply new formatting to code Run this: for i in **/*.cc **/*.c **/*.h **/*.hh; do clang-format < $i >| $i.new && mv $i.new $i done
2022-04-02 21:14:10 +00:00
} else if (parameter == "uncompress") {
QPDFJob: move private members into Members
2022-01-26 19:56:24 +00:00
o.m->stream_data_mode = qpdf_s_uncompress;
Programmatically apply new formatting to code Run this: for i in **/*.cc **/*.c **/*.h **/*.hh; do clang-format < $i >| $i.new && mv $i.new $i done
2022-04-02 21:14:10 +00:00
} else {
QPDFJob: move more top-level trivial handlers into config
2022-01-26 00:21:46 +00:00
usage("invalid stream-data option");
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
return this;
QPDFJob: move more top-level trivial handlers into config
2022-01-26 00:21:46 +00:00
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
QPDFJob::Config*
Make QPDFArgParser accept const argv This makes it much more convention to use the initializeFromArgv functions since you can use string literals.
2022-02-01 18:37:31 +00:00
QPDFJob::Config::decodeLevel(std::string const& parameter)
QPDFJob: move more top-level trivial handlers into config
2022-01-26 00:21:46 +00:00
{
QPDFJob: move private members into Members
2022-01-26 19:56:24 +00:00
o.m->decode_level_set = true;
Programmatically apply new formatting to code Run this: for i in **/*.cc **/*.c **/*.h **/*.hh; do clang-format < $i >| $i.new && mv $i.new $i done
2022-04-02 21:14:10 +00:00
if (parameter == "none") {
QPDFJob: move private members into Members
2022-01-26 19:56:24 +00:00
o.m->decode_level = qpdf_dl_none;
Programmatically apply new formatting to code Run this: for i in **/*.cc **/*.c **/*.h **/*.hh; do clang-format < $i >| $i.new && mv $i.new $i done
2022-04-02 21:14:10 +00:00
} else if (parameter == "generalized") {
QPDFJob: move private members into Members
2022-01-26 19:56:24 +00:00
o.m->decode_level = qpdf_dl_generalized;
Programmatically apply new formatting to code Run this: for i in **/*.cc **/*.c **/*.h **/*.hh; do clang-format < $i >| $i.new && mv $i.new $i done
2022-04-02 21:14:10 +00:00
} else if (parameter == "specialized") {
QPDFJob: move private members into Members
2022-01-26 19:56:24 +00:00
o.m->decode_level = qpdf_dl_specialized;
Programmatically apply new formatting to code Run this: for i in **/*.cc **/*.c **/*.h **/*.hh; do clang-format < $i >| $i.new && mv $i.new $i done
2022-04-02 21:14:10 +00:00
} else if (parameter == "all") {
QPDFJob: move private members into Members
2022-01-26 19:56:24 +00:00
o.m->decode_level = qpdf_dl_all;
Programmatically apply new formatting to code Run this: for i in **/*.cc **/*.c **/*.h **/*.hh; do clang-format < $i >| $i.new && mv $i.new $i done
2022-04-02 21:14:10 +00:00
} else {
QPDFJob: move more top-level trivial handlers into config
2022-01-26 00:21:46 +00:00
usage("invalid option");
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
return this;
QPDFJob: move more top-level trivial handlers into config
2022-01-26 00:21:46 +00:00
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
QPDFJob::Config*
Make QPDFArgParser accept const argv This makes it much more convention to use the initializeFromArgv functions since you can use string literals.
2022-02-01 18:37:31 +00:00
QPDFJob::Config::objectStreams(std::string const& parameter)
QPDFJob: move more top-level trivial handlers into config
2022-01-26 00:21:46 +00:00
{
QPDFJob: move private members into Members
2022-01-26 19:56:24 +00:00
o.m->object_stream_set = true;
Programmatically apply new formatting to code Run this: for i in **/*.cc **/*.c **/*.h **/*.hh; do clang-format < $i >| $i.new && mv $i.new $i done
2022-04-02 21:14:10 +00:00
if (parameter == "disable") {
QPDFJob: move private members into Members
2022-01-26 19:56:24 +00:00
o.m->object_stream_mode = qpdf_o_disable;
Programmatically apply new formatting to code Run this: for i in **/*.cc **/*.c **/*.h **/*.hh; do clang-format < $i >| $i.new && mv $i.new $i done
2022-04-02 21:14:10 +00:00
} else if (parameter == "preserve") {
QPDFJob: move private members into Members
2022-01-26 19:56:24 +00:00
o.m->object_stream_mode = qpdf_o_preserve;
Programmatically apply new formatting to code Run this: for i in **/*.cc **/*.c **/*.h **/*.hh; do clang-format < $i >| $i.new && mv $i.new $i done
2022-04-02 21:14:10 +00:00
} else if (parameter == "generate") {
QPDFJob: move private members into Members
2022-01-26 19:56:24 +00:00
o.m->object_stream_mode = qpdf_o_generate;
Programmatically apply new formatting to code Run this: for i in **/*.cc **/*.c **/*.h **/*.hh; do clang-format < $i >| $i.new && mv $i.new $i done
2022-04-02 21:14:10 +00:00
} else {
QPDFJob: move more top-level trivial handlers into config
2022-01-26 00:21:46 +00:00
usage("invalid object stream mode");
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
return this;
QPDFJob: move more top-level trivial handlers into config
2022-01-26 00:21:46 +00:00
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
QPDFJob::Config*
Make QPDFArgParser accept const argv This makes it much more convention to use the initializeFromArgv functions since you can use string literals.
2022-02-01 18:37:31 +00:00
QPDFJob::Config::removeUnreferencedResources(std::string const& parameter)
QPDFJob: move more top-level trivial handlers into config
2022-01-26 00:21:46 +00:00
{
Programmatically apply new formatting to code Run this: for i in **/*.cc **/*.c **/*.h **/*.hh; do clang-format < $i >| $i.new && mv $i.new $i done
2022-04-02 21:14:10 +00:00
if (parameter == "auto") {
QPDFJob: move private members into Members
2022-01-26 19:56:24 +00:00
o.m->remove_unreferenced_page_resources = QPDFJob::re_auto;
Programmatically apply new formatting to code Run this: for i in **/*.cc **/*.c **/*.h **/*.hh; do clang-format < $i >| $i.new && mv $i.new $i done
2022-04-02 21:14:10 +00:00
} else if (parameter == "yes") {
QPDFJob: move private members into Members
2022-01-26 19:56:24 +00:00
o.m->remove_unreferenced_page_resources = QPDFJob::re_yes;
Programmatically apply new formatting to code Run this: for i in **/*.cc **/*.c **/*.h **/*.hh; do clang-format < $i >| $i.new && mv $i.new $i done
2022-04-02 21:14:10 +00:00
} else if (parameter == "no") {
QPDFJob: move private members into Members
2022-01-26 19:56:24 +00:00
o.m->remove_unreferenced_page_resources = QPDFJob::re_no;
Programmatically apply new formatting to code Run this: for i in **/*.cc **/*.c **/*.h **/*.hh; do clang-format < $i >| $i.new && mv $i.new $i done
2022-04-02 21:14:10 +00:00
} else {
QPDFJob: move more top-level trivial handlers into config
2022-01-26 00:21:46 +00:00
usage("invalid value for --remove-unreferenced-page-resources");
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
return this;
QPDFJob: move more top-level trivial handlers into config
2022-01-26 00:21:46 +00:00
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
QPDFJob::Config*
Make QPDFArgParser accept const argv This makes it much more convention to use the initializeFromArgv functions since you can use string literals.
2022-02-01 18:37:31 +00:00
QPDFJob::Config::showObject(std::string const& parameter)
QPDFJob: move more top-level trivial handlers into config
2022-01-26 00:21:46 +00:00
{
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
{
Replace PointerHolder with std::shared_ptr in library sources only (patrepl and cleanpatch are my own utilities) patrepl s/PointerHolder/std::shared_ptr/g {include,libqpdf}/qpdf/*.hh patrepl s/PointerHolder/std::shared_ptr/g libqpdf/*.cc patrepl s/make_pointer_holder/std::make_shared/g libqpdf/*.cc patrepl s/make_array_pointer_holder/QUtil::make_shared_array/g libqpdf/*.cc patrepl s,qpdf/std::shared_ptr,qpdf/PointerHolder, **/*.cc **/*.hh git restore include/qpdf/PointerHolder.hh cleanpatch ./format-code
2022-04-09 18:35:56 +00:00
std::shared_ptr<char> file_buf;
QPDFJob: move more top-level trivial handlers into config
2022-01-26 00:21:46 +00:00
size_t size;
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
QUtil::read_file_into_memory(parameter.c_str(), file_buf, size);
Programmatically apply new formatting to code Run this: for i in **/*.cc **/*.c **/*.h **/*.hh; do clang-format < $i >| $i.new && mv $i.new $i done
2022-04-02 21:14:10 +00:00
try {
PointerHolder: deprecate getPointer() and getRefcount() Use get() and use_count() instead. Add #define NO_POINTERHOLDER_DEPRECATION to remove deprecation markers for these only. This commit also removes all deprecated PointerHolder API calls from qpdf's code except in PointerHolder's test suite, which must continue to test the deprecated APIs.
2022-02-04 15:10:19 +00:00
o.initializeFromJson(std::string(file_buf.get(), size), true);
Programmatically apply new formatting to code Run this: for i in **/*.cc **/*.c **/*.h **/*.hh; do clang-format < $i >| $i.new && mv $i.new $i done
2022-04-02 21:14:10 +00:00
} catch (std::exception& e) {
QPDFJob: move more top-level trivial handlers into config
2022-01-26 00:21:46 +00:00
throw std::runtime_error(
Fix typo in error message
2022-01-29 17:53:35 +00:00
"error with job-json file " + std::string(parameter) + ": " +
QPDFJob: move more top-level trivial handlers into config
2022-01-26 00:21:46 +00:00
e.what() + "\nRun " + this->o.m->message_prefix +
Fix typo in error message
2022-04-10 19:02:56 +00:00
" --job-json-help for information on the file format.");
QPDFJob: move more top-level trivial handlers into config
2022-01-26 00:21:46 +00:00
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
return this;
QPDFJob: move more top-level trivial handlers into config
2022-01-26 00:21:46 +00:00
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
QPDFJob::Config*
Make QPDFArgParser accept const argv This makes it much more convention to use the initializeFromArgv functions since you can use string literals.
2022-02-01 18:37:31 +00:00
QPDFJob::Config::rotate(std::string const& parameter)
QPDFJob: convert under/overlay and rotate
2022-01-26 14:38:34 +00:00
{
o.parseRotationParameter(parameter);
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
return this;
QPDFJob: convert under/overlay and rotate
2022-01-26 14:38:34 +00:00
}
QPDFJob: convert a flag in other than the main table
2022-01-25 16:07:53 +00:00
std::shared_ptr<QPDFJob::CopyAttConfig>
QPDFJob::Config::copyAttachmentsFrom()
{
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
return std::shared_ptr<CopyAttConfig>(new CopyAttConfig(this));
QPDFJob: convert a flag in other than the main table
2022-01-25 16:07:53 +00:00
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
QPDFJob::CopyAttConfig::CopyAttConfig(Config* c) :
QPDFJob: convert a flag in other than the main table
2022-01-25 16:07:53 +00:00
config(c)
{
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
QPDFJob::CopyAttConfig*
Make QPDFArgParser accept const argv This makes it much more convention to use the initializeFromArgv functions since you can use string literals.
2022-02-01 18:37:31 +00:00
QPDFJob::CopyAttConfig::file(std::string const& parameter)
QPDFJob: convert a flag in other than the main table
2022-01-25 16:07:53 +00:00
{
this->caf.path = parameter;
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
return this;
QPDFJob: convert a flag in other than the main table
2022-01-25 16:07:53 +00:00
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
QPDFJob::CopyAttConfig*
Make QPDFArgParser accept const argv This makes it much more convention to use the initializeFromArgv functions since you can use string literals.
2022-02-01 18:37:31 +00:00
QPDFJob::CopyAttConfig::prefix(std::string const& parameter)
QPDFJob: convert a flag in other than the main table
2022-01-25 16:07:53 +00:00
{
this->caf.prefix = parameter;
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
return this;
QPDFJob: convert a flag in other than the main table
2022-01-25 16:07:53 +00:00
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
QPDFJob::CopyAttConfig*
Make QPDFArgParser accept const argv This makes it much more convention to use the initializeFromArgv functions since you can use string literals.
2022-02-01 18:37:31 +00:00
QPDFJob::CopyAttConfig::password(std::string const& parameter)
QPDFJob: convert a flag in other than the main table
2022-01-25 16:07:53 +00:00
{
this->caf.password = parameter;
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
return this;
QPDFJob: convert a flag in other than the main table
2022-01-25 16:07:53 +00:00
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
QPDFJob::Config*
QPDFJob: use manually named end functions for Config classes Use named functions rather than just end() for clarity.
2022-01-26 22:02:30 +00:00
QPDFJob::CopyAttConfig::endCopyAttachmentsFrom()
QPDFJob: convert a flag in other than the main table
2022-01-25 16:07:53 +00:00
{
Programmatically apply new formatting to code Run this: for i in **/*.cc **/*.c **/*.h **/*.hh; do clang-format < $i >| $i.new && mv $i.new $i done
2022-04-02 21:14:10 +00:00
if (this->caf.path.empty()) {
Change filename or path to file in json and QPDFJob Use "file" consistently for specifying a file path. We use "filename" when adding attachments for a completely different purpose.
2022-01-31 18:07:19 +00:00
usage("copy attachments: no file specified");
QPDFJob: convert a flag in other than the main table
2022-01-25 16:07:53 +00:00
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
this->config->o.m->attachments_to_copy.push_back(this->caf);
QPDFJob: convert a flag in other than the main table
2022-01-25 16:07:53 +00:00
return this->config;
}
QPDFJob: convert AddAttachment handlers
2022-01-25 21:37:17 +00:00
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
QPDFJob::AttConfig::AttConfig(Config* c) :
QPDFJob: convert AddAttachment handlers
2022-01-25 21:37:17 +00:00
config(c)
{
}
std::shared_ptr<QPDFJob::AttConfig>
QPDFJob::Config::addAttachment()
{
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
return std::shared_ptr<AttConfig>(new AttConfig(this));
QPDFJob: convert AddAttachment handlers
2022-01-25 21:37:17 +00:00
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
QPDFJob::AttConfig*
Make QPDFArgParser accept const argv This makes it much more convention to use the initializeFromArgv functions since you can use string literals.
2022-02-01 18:37:31 +00:00
QPDFJob::AttConfig::file(std::string const& parameter)
QPDFJob: convert AddAttachment handlers
2022-01-25 21:37:17 +00:00
{
this->att.path = parameter;
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
return this;
QPDFJob: convert AddAttachment handlers
2022-01-25 21:37:17 +00:00
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
QPDFJob::AttConfig*
Make QPDFArgParser accept const argv This makes it much more convention to use the initializeFromArgv functions since you can use string literals.
2022-02-01 18:37:31 +00:00
QPDFJob::AttConfig::key(std::string const& parameter)
QPDFJob: convert AddAttachment handlers
2022-01-25 21:37:17 +00:00
{
this->att.key = parameter;
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
return this;
QPDFJob: convert AddAttachment handlers
2022-01-25 21:37:17 +00:00
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
QPDFJob::AttConfig*
Make QPDFArgParser accept const argv This makes it much more convention to use the initializeFromArgv functions since you can use string literals.
2022-02-01 18:37:31 +00:00
QPDFJob::AttConfig::filename(std::string const& parameter)
QPDFJob: convert AddAttachment handlers
2022-01-25 21:37:17 +00:00
{
this->att.filename = parameter;
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
return this;
QPDFJob: convert AddAttachment handlers
2022-01-25 21:37:17 +00:00
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
QPDFJob::AttConfig*
Make QPDFArgParser accept const argv This makes it much more convention to use the initializeFromArgv functions since you can use string literals.
2022-02-01 18:37:31 +00:00
QPDFJob::AttConfig::creationdate(std::string const& parameter)
QPDFJob: convert AddAttachment handlers
2022-01-25 21:37:17 +00:00
{
Programmatically apply new formatting to code Run this: for i in **/*.cc **/*.c **/*.h **/*.hh; do clang-format < $i >| $i.new && mv $i.new $i done
2022-04-02 21:14:10 +00:00
if (!QUtil::pdf_time_to_qpdf_time(parameter)) {
QPDFJob: move more top-level trivial handlers into config
2022-01-26 00:21:46 +00:00
usage(std::string(parameter) + " is not a valid PDF timestamp");
QPDFJob: convert AddAttachment handlers
2022-01-25 21:37:17 +00:00
}
this->att.creationdate = parameter;
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
return this;
QPDFJob: convert AddAttachment handlers
2022-01-25 21:37:17 +00:00
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
QPDFJob::AttConfig*
Make QPDFArgParser accept const argv This makes it much more convention to use the initializeFromArgv functions since you can use string literals.
2022-02-01 18:37:31 +00:00
QPDFJob::AttConfig::moddate(std::string const& parameter)
QPDFJob: convert AddAttachment handlers
2022-01-25 21:37:17 +00:00
{
Programmatically apply new formatting to code Run this: for i in **/*.cc **/*.c **/*.h **/*.hh; do clang-format < $i >| $i.new && mv $i.new $i done
2022-04-02 21:14:10 +00:00
if (!QUtil::pdf_time_to_qpdf_time(parameter)) {
QPDFJob: move more top-level trivial handlers into config
2022-01-26 00:21:46 +00:00
usage(std::string(parameter) + " is not a valid PDF timestamp");
QPDFJob: convert AddAttachment handlers
2022-01-25 21:37:17 +00:00
}
this->att.moddate = parameter;
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
return this;
QPDFJob: convert AddAttachment handlers
2022-01-25 21:37:17 +00:00
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
QPDFJob::AttConfig*
Make QPDFArgParser accept const argv This makes it much more convention to use the initializeFromArgv functions since you can use string literals.
2022-02-01 18:37:31 +00:00
QPDFJob::AttConfig::mimetype(std::string const& parameter)
QPDFJob: convert AddAttachment handlers
2022-01-25 21:37:17 +00:00
{
Programmatically apply new formatting to code Run this: for i in **/*.cc **/*.c **/*.h **/*.hh; do clang-format < $i >| $i.new && mv $i.new $i done
2022-04-02 21:14:10 +00:00
if (parameter.find('/') == std::string::npos) {
QPDFJob: move more top-level trivial handlers into config
2022-01-26 00:21:46 +00:00
usage("mime type should be specified as type/subtype");
QPDFJob: convert AddAttachment handlers
2022-01-25 21:37:17 +00:00
}
this->att.mimetype = parameter;
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
return this;
QPDFJob: convert AddAttachment handlers
2022-01-25 21:37:17 +00:00
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
QPDFJob::AttConfig*
Make QPDFArgParser accept const argv This makes it much more convention to use the initializeFromArgv functions since you can use string literals.
2022-02-01 18:37:31 +00:00
QPDFJob::AttConfig::description(std::string const& parameter)
QPDFJob: convert AddAttachment handlers
2022-01-25 21:37:17 +00:00
{
this->att.description = parameter;
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
return this;
QPDFJob: convert AddAttachment handlers
2022-01-25 21:37:17 +00:00
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
QPDFJob::AttConfig*
QPDFJob: convert AddAttachment handlers
2022-01-25 21:37:17 +00:00
QPDFJob::AttConfig::replace()
{
this->att.replace = true;
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
return this;
QPDFJob: convert AddAttachment handlers
2022-01-25 21:37:17 +00:00
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
QPDFJob::Config*
QPDFJob: use manually named end functions for Config classes Use named functions rather than just end() for clarity.
2022-01-26 22:02:30 +00:00
QPDFJob::AttConfig::endAddAttachment()
QPDFJob: convert AddAttachment handlers
2022-01-25 21:37:17 +00:00
{
Programmatically apply new formatting to code Run this: for i in **/*.cc **/*.c **/*.h **/*.hh; do clang-format < $i >| $i.new && mv $i.new $i done
2022-04-02 21:14:10 +00:00
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);
Programmatically apply new formatting to code Run this: for i in **/*.cc **/*.c **/*.h **/*.hh; do clang-format < $i >| $i.new && mv $i.new $i done
2022-04-02 21:14:10 +00:00
if (last_element.empty()) {
Change filename or path to file in json and QPDFJob Use "file" consistently for specifying a file path. We use "filename" when adding attachments for a completely different purpose.
2022-01-31 18:07:19 +00:00
usage("file for --add-attachment may not be empty");
QPDFJob: convert AddAttachment handlers
2022-01-25 21:37:17 +00:00
}
Programmatically apply new formatting to code Run this: for i in **/*.cc **/*.c **/*.h **/*.hh; do clang-format < $i >| $i.new && mv $i.new $i done
2022-04-02 21:14:10 +00:00
if (this->att.filename.empty()) {
QPDFJob: convert AddAttachment handlers
2022-01-25 21:37:17 +00:00
this->att.filename = last_element;
}
Programmatically apply new formatting to code Run this: for i in **/*.cc **/*.c **/*.h **/*.hh; do clang-format < $i >| $i.new && mv $i.new $i done
2022-04-02 21:14:10 +00:00
if (this->att.key.empty()) {
QPDFJob: convert AddAttachment handlers
2022-01-25 21:37:17 +00:00
this->att.key = last_element;
}
Programmatically apply new formatting to code Run this: for i in **/*.cc **/*.c **/*.h **/*.hh; do clang-format < $i >| $i.new && mv $i.new $i done
2022-04-02 21:14:10 +00:00
if (this->att.creationdate.empty()) {
QPDFJob: convert AddAttachment handlers
2022-01-25 21:37:17 +00:00
this->att.creationdate = now;
}
Programmatically apply new formatting to code Run this: for i in **/*.cc **/*.c **/*.h **/*.hh; do clang-format < $i >| $i.new && mv $i.new $i done
2022-04-02 21:14:10 +00:00
if (this->att.moddate.empty()) {
QPDFJob: convert AddAttachment handlers
2022-01-25 21:37:17 +00:00
this->att.moddate = now;
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
this->config->o.m->attachments_to_add.push_back(this->att);
QPDFJob: convert AddAttachment handlers
2022-01-25 21:37:17 +00:00
return this->config;
}
QPDFJob: convert pages
2022-01-26 00:01:10 +00:00
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
QPDFJob::PagesConfig::PagesConfig(Config* c) :
QPDFJob: convert pages
2022-01-26 00:01:10 +00:00
config(c)
{
}
std::shared_ptr<QPDFJob::PagesConfig>
QPDFJob::Config::pages()
{
Programmatically apply new formatting to code Run this: for i in **/*.cc **/*.c **/*.h **/*.hh; do clang-format < $i >| $i.new && mv $i.new $i done
2022-04-02 21:14:10 +00:00
if (!o.m->page_specs.empty()) {
QPDFJob: eliminate most access to QPDFJob members from ArgParser All that's left now is input and output handling.
2022-01-26 18:39:22 +00:00
usage("--pages may only be specified one time");
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
return std::shared_ptr<PagesConfig>(new PagesConfig(this));
QPDFJob: convert pages
2022-01-26 00:01:10 +00:00
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
QPDFJob::Config*
QPDFJob: use manually named end functions for Config classes Use named functions rather than just end() for clarity.
2022-01-26 22:02:30 +00:00
QPDFJob::PagesConfig::endPages()
QPDFJob: convert pages
2022-01-26 00:01:10 +00:00
{
Programmatically apply new formatting to code Run this: for i in **/*.cc **/*.c **/*.h **/*.hh; do clang-format < $i >| $i.new && mv $i.new $i done
2022-04-02 21:14:10 +00:00
if (this->config->o.m->page_specs.empty()) {
QPDFJob: move more top-level trivial handlers into config
2022-01-26 00:21:46 +00:00
usage("--pages: no page specifications given");
QPDFJob: convert pages
2022-01-26 00:01:10 +00:00
}
return this->config;
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
QPDFJob::PagesConfig*
Programmatically apply new formatting to code Run this: for i in **/*.cc **/*.c **/*.h **/*.hh; do clang-format < $i >| $i.new && mv $i.new $i done
2022-04-02 21:14:10 +00:00
QPDFJob::PagesConfig::pageSpec(
std::string const& filename, std::string const& range, char const* password)
QPDFJob: convert pages
2022-01-26 00:01:10 +00:00
{
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you 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->page_specs.push_back(
QPDFJob: convert pages
2022-01-26 00:01:10 +00:00
QPDFJob::PageSpec(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
{
Programmatically apply new formatting to code Run this: for i in **/*.cc **/*.c **/*.h **/*.hh; do clang-format < $i >| $i.new && mv $i.new $i done
2022-04-02 21:14:10 +00:00
if (config->o.m->under_overlay->filename.empty()) {
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
usage(config->o.m->under_overlay->which + " file not specified");
QPDFJob: convert under/overlay and rotate
2022-01-26 14:38:34 +00:00
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you 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 = 0;
QPDFJob: convert under/overlay and rotate
2022-01-26 14:38:34 +00:00
return this->config;
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
QPDFJob::UOConfig*
Make QPDFArgParser accept const argv This makes it much more convention to use the initializeFromArgv functions since you can use string literals.
2022-02-01 18:37:31 +00:00
QPDFJob::UOConfig::file(std::string const& parameter)
QPDFJob: convert under/overlay and rotate
2022-01-26 14:38:34 +00:00
{
Programmatically apply new formatting to code Run this: for i in **/*.cc **/*.c **/*.h **/*.hh; do clang-format < $i >| $i.new && mv $i.new $i done
2022-04-02 21:14:10 +00:00
if (!config->o.m->under_overlay->filename.empty()) {
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
usage(config->o.m->under_overlay->which + " file already specified");
Programmatically apply new formatting to code Run this: for i in **/*.cc **/*.c **/*.h **/*.hh; do clang-format < $i >| $i.new && mv $i.new $i done
2022-04-02 21:14:10 +00:00
} else {
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
config->o.m->under_overlay->filename = parameter;
QPDFJob: convert under/overlay and rotate
2022-01-26 14:38:34 +00:00
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
return this;
QPDFJob: convert under/overlay and rotate
2022-01-26 14:38:34 +00:00
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
QPDFJob::UOConfig*
Make QPDFArgParser accept const argv This makes it much more convention to use the initializeFromArgv functions since you can use string literals.
2022-02-01 18:37:31 +00:00
QPDFJob::UOConfig::to(std::string const& parameter)
QPDFJob: convert under/overlay and rotate
2022-01-26 14:38:34 +00:00
{
Make QPDFArgParser accept const argv This makes it much more convention to use the initializeFromArgv functions since you can use string literals.
2022-02-01 18:37:31 +00:00
config->o.parseNumrange(parameter.c_str(), 0);
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
config->o.m->under_overlay->to_nr = parameter;
return this;
QPDFJob: convert under/overlay and rotate
2022-01-26 14:38:34 +00:00
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
QPDFJob::UOConfig*
Make QPDFArgParser accept const argv This makes it much more convention to use the initializeFromArgv functions since you can use string literals.
2022-02-01 18:37:31 +00:00
QPDFJob::UOConfig::from(std::string const& parameter)
QPDFJob: convert under/overlay and rotate
2022-01-26 14:38:34 +00:00
{
Programmatically apply new formatting to code Run this: for i in **/*.cc **/*.c **/*.h **/*.hh; do clang-format < $i >| $i.new && mv $i.new $i done
2022-04-02 21:14:10 +00:00
if (!parameter.empty()) {
Make QPDFArgParser accept const argv This makes it much more convention to use the initializeFromArgv functions since you can use string literals.
2022-02-01 18:37:31 +00:00
config->o.parseNumrange(parameter.c_str(), 0);
QPDFJob: convert under/overlay and rotate
2022-01-26 14:38:34 +00:00
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
config->o.m->under_overlay->from_nr = parameter;
return this;
QPDFJob: convert under/overlay and rotate
2022-01-26 14:38:34 +00:00
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
QPDFJob::UOConfig*
Make QPDFArgParser accept const argv This makes it much more convention to use the initializeFromArgv functions since you can use string literals.
2022-02-01 18:37:31 +00:00
QPDFJob::UOConfig::repeat(std::string const& parameter)
QPDFJob: convert under/overlay and rotate
2022-01-26 14:38:34 +00:00
{
Programmatically apply new formatting to code Run this: for i in **/*.cc **/*.c **/*.h **/*.hh; do clang-format < $i >| $i.new && mv $i.new $i done
2022-04-02 21:14:10 +00:00
if (!parameter.empty()) {
Make QPDFArgParser accept const argv This makes it much more convention to use the initializeFromArgv functions since you can use string literals.
2022-02-01 18:37:31 +00:00
config->o.parseNumrange(parameter.c_str(), 0);
QPDFJob: convert under/overlay and rotate
2022-01-26 14:38:34 +00:00
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
config->o.m->under_overlay->repeat_nr = parameter;
return this;
QPDFJob: convert under/overlay and rotate
2022-01-26 14:38:34 +00:00
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
QPDFJob::UOConfig*
Make QPDFArgParser accept const argv This makes it much more convention to use the initializeFromArgv functions since you can use string literals.
2022-02-01 18:37:31 +00:00
QPDFJob::UOConfig::password(std::string const& parameter)
QPDFJob: convert under/overlay and rotate
2022-01-26 14:38:34 +00:00
{
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
config->o.m->under_overlay->password = QUtil::make_shared_cstr(parameter);
return this;
QPDFJob: convert under/overlay and rotate
2022-01-26 14:38:34 +00:00
}
QPDFJob: convert encryption handlers
2022-01-26 18:17:57 +00:00
std::shared_ptr<QPDFJob::EncConfig>
Programmatically apply new formatting to code Run this: for i in **/*.cc **/*.c **/*.h **/*.hh; do clang-format < $i >| $i.new && mv $i.new $i done
2022-04-02 21:14:10 +00:00
QPDFJob::Config::encrypt(
int keylen,
std::string const& user_password,
std::string const& owner_password)
QPDFJob: convert encryption handlers
2022-01-26 18:17:57 +00:00
{
QPDFJob: move private members into Members
2022-01-26 19:56:24 +00:00
o.m->keylen = keylen;
Programmatically apply new formatting to code Run this: for i in **/*.cc **/*.c **/*.h **/*.hh; do clang-format < $i >| $i.new && mv $i.new $i done
2022-04-02 21:14:10 +00:00
if (keylen == 256) {
QPDFJob: move private members into Members
2022-01-26 19:56:24 +00:00
o.m->use_aes = true;
QPDFJob: convert encryption handlers
2022-01-26 18:17:57 +00:00
}
QPDFJob: move private members into Members
2022-01-26 19:56:24 +00:00
o.m->user_password = user_password;
o.m->owner_password = owner_password;
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
return std::shared_ptr<EncConfig>(new EncConfig(this));
QPDFJob: convert encryption handlers
2022-01-26 18:17:57 +00:00
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you 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
{
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
config->o.m->encrypt = true;
config->o.m->decrypt = false;
config->o.m->copy_encryption = false;
QPDFJob: convert encryption handlers
2022-01-26 18:17:57 +00:00
return this->config;
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
QPDFJob::EncConfig*
QPDFJob: convert encryption handlers
2022-01-26 18:17:57 +00:00
QPDFJob::EncConfig::allowInsecure()
{
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
config->o.m->allow_insecure = true;
return this;
QPDFJob: convert encryption handlers
2022-01-26 18:17:57 +00:00
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
QPDFJob::EncConfig*
Make QPDFArgParser accept const argv This makes it much more convention to use the initializeFromArgv functions since you can use string literals.
2022-02-01 18:37:31 +00:00
QPDFJob::EncConfig::accessibility(std::string const& parameter)
QPDFJob: convert encryption handlers
2022-01-26 18:17:57 +00:00
{
Make QPDFArgParser accept const argv This makes it much more convention to use the initializeFromArgv functions since you can use string literals.
2022-02-01 18:37:31 +00:00
config->o.m->r3_accessibility = (parameter == "y");
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
return this;
QPDFJob: convert encryption handlers
2022-01-26 18:17:57 +00:00
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
QPDFJob::EncConfig*
Make QPDFArgParser accept const argv This makes it much more convention to use the initializeFromArgv functions since you can use string literals.
2022-02-01 18:37:31 +00:00
QPDFJob::EncConfig::extract(std::string const& parameter)
QPDFJob: convert encryption handlers
2022-01-26 18:17:57 +00:00
{
Programmatically apply new formatting to code Run this: for i in **/*.cc **/*.c **/*.h **/*.hh; do clang-format < $i >| $i.new && mv $i.new $i done
2022-04-02 21:14:10 +00:00
if (config->o.m->keylen == 40) {
Make QPDFArgParser accept const argv This makes it much more convention to use the initializeFromArgv functions since you can use string literals.
2022-02-01 18:37:31 +00:00
config->o.m->r2_extract = (parameter == "y");
Programmatically apply new formatting to code Run this: for i in **/*.cc **/*.c **/*.h **/*.hh; do clang-format < $i >| $i.new && mv $i.new $i done
2022-04-02 21:14:10 +00:00
} else {
Make QPDFArgParser accept const argv This makes it much more convention to use the initializeFromArgv functions since you can use string literals.
2022-02-01 18:37:31 +00:00
config->o.m->r3_extract = (parameter == "y");
QPDFJob: convert encryption handlers
2022-01-26 18:17:57 +00:00
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
return this;
QPDFJob: convert encryption handlers
2022-01-26 18:17:57 +00:00
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
QPDFJob::EncConfig*
Make QPDFArgParser accept const argv This makes it much more convention to use the initializeFromArgv functions since you can use string literals.
2022-02-01 18:37:31 +00:00
QPDFJob::EncConfig::print(std::string const& parameter)
QPDFJob: convert encryption handlers
2022-01-26 18:17:57 +00:00
{
Programmatically apply new formatting to code Run this: for i in **/*.cc **/*.c **/*.h **/*.hh; do clang-format < $i >| $i.new && mv $i.new $i done
2022-04-02 21:14:10 +00:00
if (config->o.m->keylen == 40) {
Make QPDFArgParser accept const argv This makes it much more convention to use the initializeFromArgv functions since you can use string literals.
2022-02-01 18:37:31 +00:00
config->o.m->r2_print = (parameter == "y");
Programmatically apply new formatting to code Run this: for i in **/*.cc **/*.c **/*.h **/*.hh; do clang-format < $i >| $i.new && mv $i.new $i done
2022-04-02 21:14:10 +00:00
} else if (parameter == "full") {
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
config->o.m->r3_print = qpdf_r3p_full;
Programmatically apply new formatting to code Run this: for i in **/*.cc **/*.c **/*.h **/*.hh; do clang-format < $i >| $i.new && mv $i.new $i done
2022-04-02 21:14:10 +00:00
} else if (parameter == "low") {
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
config->o.m->r3_print = qpdf_r3p_low;
Programmatically apply new formatting to code Run this: for i in **/*.cc **/*.c **/*.h **/*.hh; do clang-format < $i >| $i.new && mv $i.new $i done
2022-04-02 21:14:10 +00:00
} else if (parameter == "none") {
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
config->o.m->r3_print = qpdf_r3p_none;
Programmatically apply new formatting to code Run this: for i in **/*.cc **/*.c **/*.h **/*.hh; do clang-format < $i >| $i.new && mv $i.new $i done
2022-04-02 21:14:10 +00:00
} else {
QPDFJob: convert encryption handlers
2022-01-26 18:17:57 +00:00
usage("invalid print option");
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
return this;
QPDFJob: convert encryption handlers
2022-01-26 18:17:57 +00:00
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
QPDFJob::EncConfig*
Make QPDFArgParser accept const argv This makes it much more convention to use the initializeFromArgv functions since you can use string literals.
2022-02-01 18:37:31 +00:00
QPDFJob::EncConfig::modify(std::string const& parameter)
QPDFJob: convert encryption handlers
2022-01-26 18:17:57 +00:00
{
Programmatically apply new formatting to code Run this: for i in **/*.cc **/*.c **/*.h **/*.hh; do clang-format < $i >| $i.new && mv $i.new $i done
2022-04-02 21:14:10 +00:00
if (config->o.m->keylen == 40) {
Make QPDFArgParser accept const argv This makes it much more convention to use the initializeFromArgv functions since you can use string literals.
2022-02-01 18:37:31 +00:00
config->o.m->r2_modify = (parameter == "y");
Programmatically apply new formatting to code Run this: for i in **/*.cc **/*.c **/*.h **/*.hh; do clang-format < $i >| $i.new && mv $i.new $i done
2022-04-02 21:14:10 +00:00
} else if (parameter == "all") {
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
config->o.m->r3_assemble = true;
config->o.m->r3_annotate_and_form = true;
config->o.m->r3_form_filling = true;
config->o.m->r3_modify_other = true;
Programmatically apply new formatting to code Run this: for i in **/*.cc **/*.c **/*.h **/*.hh; do clang-format < $i >| $i.new && mv $i.new $i done
2022-04-02 21:14:10 +00:00
} else if (parameter == "annotate") {
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
config->o.m->r3_assemble = true;
config->o.m->r3_annotate_and_form = true;
config->o.m->r3_form_filling = true;
config->o.m->r3_modify_other = false;
Programmatically apply new formatting to code Run this: for i in **/*.cc **/*.c **/*.h **/*.hh; do clang-format < $i >| $i.new && mv $i.new $i done
2022-04-02 21:14:10 +00:00
} else if (parameter == "form") {
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
config->o.m->r3_assemble = true;
config->o.m->r3_annotate_and_form = false;
config->o.m->r3_form_filling = true;
config->o.m->r3_modify_other = false;
Programmatically apply new formatting to code Run this: for i in **/*.cc **/*.c **/*.h **/*.hh; do clang-format < $i >| $i.new && mv $i.new $i done
2022-04-02 21:14:10 +00:00
} else if (parameter == "assembly") {
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
config->o.m->r3_assemble = true;
config->o.m->r3_annotate_and_form = false;
config->o.m->r3_form_filling = false;
config->o.m->r3_modify_other = false;
Programmatically apply new formatting to code Run this: for i in **/*.cc **/*.c **/*.h **/*.hh; do clang-format < $i >| $i.new && mv $i.new $i done
2022-04-02 21:14:10 +00:00
} else if (parameter == "none") {
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
config->o.m->r3_assemble = false;
config->o.m->r3_annotate_and_form = false;
config->o.m->r3_form_filling = false;
config->o.m->r3_modify_other = false;
Programmatically apply new formatting to code Run this: for i in **/*.cc **/*.c **/*.h **/*.hh; do clang-format < $i >| $i.new && mv $i.new $i done
2022-04-02 21:14:10 +00:00
} else {
QPDFJob: convert encryption handlers
2022-01-26 18:17:57 +00:00
usage("invalid modify option");
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
return this;
QPDFJob: convert encryption handlers
2022-01-26 18:17:57 +00:00
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
QPDFJob::EncConfig*
QPDFJob: convert encryption handlers
2022-01-26 18:17:57 +00:00
QPDFJob::EncConfig::cleartextMetadata()
{
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
config->o.m->cleartext_metadata = true;
return this;
QPDFJob: convert encryption handlers
2022-01-26 18:17:57 +00:00
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
QPDFJob::EncConfig*
Make QPDFArgParser accept const argv This makes it much more convention to use the initializeFromArgv functions since you can use string literals.
2022-02-01 18:37:31 +00:00
QPDFJob::EncConfig::assemble(std::string const& parameter)
QPDFJob: convert encryption handlers
2022-01-26 18:17:57 +00:00
{
Make QPDFArgParser accept const argv This makes it much more convention to use the initializeFromArgv functions since you can use string literals.
2022-02-01 18:37:31 +00:00
config->o.m->r3_assemble = (parameter == "y");
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
return this;
QPDFJob: convert encryption handlers
2022-01-26 18:17:57 +00:00
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
QPDFJob::EncConfig*
Make QPDFArgParser accept const argv This makes it much more convention to use the initializeFromArgv functions since you can use string literals.
2022-02-01 18:37:31 +00:00
QPDFJob::EncConfig::annotate(std::string const& parameter)
QPDFJob: convert encryption handlers
2022-01-26 18:17:57 +00:00
{
Programmatically apply new formatting to code Run this: for i in **/*.cc **/*.c **/*.h **/*.hh; do clang-format < $i >| $i.new && mv $i.new $i done
2022-04-02 21:14:10 +00:00
if (config->o.m->keylen == 40) {
Make QPDFArgParser accept const argv This makes it much more convention to use the initializeFromArgv functions since you can use string literals.
2022-02-01 18:37:31 +00:00
config->o.m->r2_annotate = (parameter == "y");
Programmatically apply new formatting to code Run this: for i in **/*.cc **/*.c **/*.h **/*.hh; do clang-format < $i >| $i.new && mv $i.new $i done
2022-04-02 21:14:10 +00:00
} else {
Make QPDFArgParser accept const argv This makes it much more convention to use the initializeFromArgv functions since you can use string literals.
2022-02-01 18:37:31 +00:00
config->o.m->r3_annotate_and_form = (parameter == "y");
QPDFJob: convert encryption handlers
2022-01-26 18:17:57 +00:00
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
return this;
QPDFJob: convert encryption handlers
2022-01-26 18:17:57 +00:00
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
QPDFJob::EncConfig*
Make QPDFArgParser accept const argv This makes it much more convention to use the initializeFromArgv functions since you can use string literals.
2022-02-01 18:37:31 +00:00
QPDFJob::EncConfig::form(std::string const& parameter)
QPDFJob: convert encryption handlers
2022-01-26 18:17:57 +00:00
{
Make QPDFArgParser accept const argv This makes it much more convention to use the initializeFromArgv functions since you can use string literals.
2022-02-01 18:37:31 +00:00
config->o.m->r3_form_filling = (parameter == "y");
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
return this;
QPDFJob: convert encryption handlers
2022-01-26 18:17:57 +00:00
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
QPDFJob::EncConfig*
Make QPDFArgParser accept const argv This makes it much more convention to use the initializeFromArgv functions since you can use string literals.
2022-02-01 18:37:31 +00:00
QPDFJob::EncConfig::modifyOther(std::string const& parameter)
QPDFJob: convert encryption handlers
2022-01-26 18:17:57 +00:00
{
Make QPDFArgParser accept const argv This makes it much more convention to use the initializeFromArgv functions since you can use string literals.
2022-02-01 18:37:31 +00:00
config->o.m->r3_modify_other = (parameter == "y");
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
return this;
QPDFJob: convert encryption handlers
2022-01-26 18:17:57 +00:00
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
QPDFJob::EncConfig*
Make QPDFArgParser accept const argv This makes it much more convention to use the initializeFromArgv functions since you can use string literals.
2022-02-01 18:37:31 +00:00
QPDFJob::EncConfig::useAes(std::string const& parameter)
QPDFJob: convert encryption handlers
2022-01-26 18:17:57 +00:00
{
Make QPDFArgParser accept const argv This makes it much more convention to use the initializeFromArgv functions since you can use string literals.
2022-02-01 18:37:31 +00:00
config->o.m->use_aes = (parameter == "y");
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
return this;
QPDFJob: convert encryption handlers
2022-01-26 18:17:57 +00:00
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
QPDFJob::EncConfig*
QPDFJob: convert encryption handlers
2022-01-26 18:17:57 +00:00
QPDFJob::EncConfig::forceV4()
{
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
config->o.m->force_V4 = true;
return this;
QPDFJob: convert encryption handlers
2022-01-26 18:17:57 +00:00
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
QPDFJob::EncConfig*
QPDFJob: convert encryption handlers
2022-01-26 18:17:57 +00:00
QPDFJob::EncConfig::forceR5()
{
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
config->o.m->force_R5 = true;
return this;
QPDFJob: convert encryption handlers
2022-01-26 18:17:57 +00:00
}
Copy Permalink