octoleo/qpdf
2
1
Fork 0
mirror of https://github.com/qpdf/qpdf.git synced 2024-11-16 01:27:07 +00:00
Code Issues Releases Wiki Activity
6dd8465948
qpdf/libqpdf/QPDFJob_config.cc

1246 lines
26 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
QPDFJob: convert trivial functions to config API
2022-01-24 00:46:20 +00:00
#include <qpdf/QUtil.hh>
QPDFJob: move more top-level trivial handlers into config
2022-01-26 00:21:46 +00:00
#include <qpdf/QTC.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
{
QPDFJob: move private members into Members
2022-01-26 19:56:24 +00:00
if (o.m->infilename == 0)
QPDFJob: move input/output handling into config
2022-01-26 18:56:13 +00:00
{
QPDFJob: move private members into Members
2022-01-26 19:56:24 +00:00
o.m->infilename = QUtil::make_shared_cstr(filename);
QPDFJob: move input/output handling into config
2022-01-26 18:56:13 +00:00
}
else
{
usage("input file has already been given");
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
return this;
QPDFJob: move input/output handling into config
2022-01-26 18:56:13 +00:00
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
QPDFJob::Config*
QPDFJob: move input/output handling into config
2022-01-26 18:56:13 +00:00
QPDFJob::Config::emptyInput()
{
QPDFJob: move private members into Members
2022-01-26 19:56:24 +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
// infile means empty. This means that passing "" as the
// argument to inputFile, or equivalently using "" as a
// positional command-line argument would be the same as
// --empty. This probably isn't worth blocking or coding
// around, but it would be better if we had a tighter way of
// knowing that the input file is empty.
QPDFJob: move private members into Members
2022-01-26 19:56:24 +00:00
o.m->infilename = QUtil::make_shared_cstr("");
QPDFJob: move input/output handling into config
2022-01-26 18:56:13 +00:00
}
else
{
usage("empty input can't be used"
" since input file has already been given");
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
return this;
QPDFJob: move input/output handling into config
2022-01-26 18:56:13 +00:00
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
QPDFJob::Config*
Make QPDFArgParser accept const argv This makes it much more convention to use the initializeFromArgv functions since you can use string literals.
2022-02-01 18:37:31 +00:00
QPDFJob::Config::outputFile(std::string const& filename)
QPDFJob: move input/output handling into config
2022-01-26 18:56:13 +00:00
{
QPDFJob: move private members into Members
2022-01-26 19:56:24 +00:00
if ((o.m->outfilename == 0) && (! o.m->replace_input))
QPDFJob: move input/output handling into config
2022-01-26 18:56:13 +00:00
{
QPDFJob: move private members into Members
2022-01-26 19:56:24 +00:00
o.m->outfilename = QUtil::make_shared_cstr(filename);
QPDFJob: move input/output handling into config
2022-01-26 18:56:13 +00:00
}
else
{
usage("output file has already been given");
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
return this;
QPDFJob: move input/output handling into config
2022-01-26 18:56:13 +00:00
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
QPDFJob::Config*
QPDFJob: move input/output handling into config
2022-01-26 18:56:13 +00:00
QPDFJob::Config::replaceInput()
{
QPDFJob: move private members into Members
2022-01-26 19:56:24 +00:00
if ((o.m->outfilename == 0) && (! o.m->replace_input))
QPDFJob: move input/output handling into config
2022-01-26 18:56:13 +00:00
{
QPDFJob: move private members into Members
2022-01-26 19:56:24 +00:00
o.m->replace_input = true;
QPDFJob: move input/output handling into config
2022-01-26 18:56:13 +00:00
}
else
{
usage("replace-input can't be used"
" since output file has already been given");
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
return this;
QPDFJob: move input/output handling into config
2022-01-26 18:56:13 +00:00
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
QPDFJob::Config*
QPDFJob: convert trivial functions to config API
2022-01-24 00:46:20 +00:00
QPDFJob::Config::allowWeakCrypto()
{
QPDFJob: move private members into Members
2022-01-26 19:56:24 +00:00
o.m->allow_weak_crypto = true;
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
return this;
QPDFJob: convert trivial functions to config API
2022-01-24 00:46:20 +00:00
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
QPDFJob::Config*
QPDFJob: convert trivial functions to config API
2022-01-24 00:46:20 +00:00
QPDFJob::Config::check()
{
QPDFJob: move private members into Members
2022-01-26 19:56:24 +00:00
o.m->check = true;
o.m->require_outfile = false;
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
return this;
QPDFJob: convert trivial functions to config API
2022-01-24 00:46:20 +00:00
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
QPDFJob::Config*
QPDFJob: convert trivial functions to config API
2022-01-24 00:46:20 +00:00
QPDFJob::Config::checkLinearization()
{
QPDFJob: move private members into Members
2022-01-26 19:56:24 +00:00
o.m->check_linearization = true;
o.m->require_outfile = false;
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
return this;
QPDFJob: convert trivial functions to config API
2022-01-24 00:46:20 +00:00
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
QPDFJob::Config*
QPDFJob: convert trivial functions to config API
2022-01-24 00:46:20 +00:00
QPDFJob::Config::coalesceContents()
{
QPDFJob: move private members into Members
2022-01-26 19:56:24 +00:00
o.m->coalesce_contents = true;
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
return this;
QPDFJob: convert trivial functions to config API
2022-01-24 00:46:20 +00:00
}
generate_auto_job: generate overloaded config decls for optional For optional parameter/choices, generate an overloaded config method that takes no arguments. This makes it possible to convert from a bare argument to one that takes an optional parameter without breaking binary compatibility.
2022-02-01 09:16:58 +00:00
QPDFJob::Config*
QPDFJob::Config::collate()
{
Make QPDFArgParser accept const argv This makes it much more convention to use the initializeFromArgv functions since you can use string literals.
2022-02-01 18:37:31 +00:00
return collate("");
generate_auto_job: generate overloaded config decls for optional For optional parameter/choices, generate an overloaded config method that takes no arguments. This makes it possible to convert from a bare argument to one that takes an optional parameter without breaking binary compatibility.
2022-02-01 09:16:58 +00:00
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
QPDFJob::Config*
Make QPDFArgParser accept const argv This makes it much more convention to use the initializeFromArgv functions since you can use string literals.
2022-02-01 18:37:31 +00:00
QPDFJob::Config::collate(std::string const& parameter)
QPDFJob: convert trivial functions to config API
2022-01-24 00:46:20 +00:00
{
Make QPDFArgParser accept const argv This 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;
Make QPDFArgParser accept const argv This makes it much more convention to use the initializeFromArgv functions since you can use string literals.
2022-02-01 18:37:31 +00:00
if (parameter == "screen")
QPDFJob: 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_forbidden |= an_no_view;
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
else if (parameter == "print")
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_required |= an_print;
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
else if (parameter != "all")
{
usage("invalid flatten-annotations option");
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
return this;
QPDFJob: convert trivial functions to config API
2022-01-24 00:46:20 +00:00
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
QPDFJob::Config*
QPDFJob: convert trivial functions to config API
2022-01-24 00:46:20 +00:00
QPDFJob::Config::flattenRotation()
{
QPDFJob: move private members into Members
2022-01-26 19:56:24 +00:00
o.m->flatten_rotation = true;
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
return this;
QPDFJob: convert trivial functions to config API
2022-01-24 00:46:20 +00:00
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
QPDFJob::Config*
Make QPDFArgParser accept const argv This makes it much more convention to use the initializeFromArgv functions since you can use string literals.
2022-02-01 18:37:31 +00:00
QPDFJob::Config::forceVersion(std::string const& parameter)
QPDFJob: convert trivial functions to config API
2022-01-24 00:46:20 +00:00
{
QPDFJob: move private members into Members
2022-01-26 19:56:24 +00:00
o.m->force_version = parameter;
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
return this;
QPDFJob: convert trivial functions to config API
2022-01-24 00:46:20 +00:00
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
QPDFJob::Config*
QPDFJob: convert trivial functions to config API
2022-01-24 00:46:20 +00:00
QPDFJob::Config::generateAppearances()
{
QPDFJob: move private members into Members
2022-01-26 19:56:24 +00:00
o.m->generate_appearances = true;
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
return this;
QPDFJob: convert trivial functions to config API
2022-01-24 00:46:20 +00:00
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
QPDFJob::Config*
QPDFJob: convert trivial functions to config API
2022-01-24 00:46:20 +00:00
QPDFJob::Config::ignoreXrefStreams()
{
QPDFJob: move private members into Members
2022-01-26 19:56:24 +00:00
o.m->ignore_xref_streams = true;
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
return this;
QPDFJob: convert trivial functions to config API
2022-01-24 00:46:20 +00:00
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
QPDFJob::Config*
Make QPDFArgParser accept const argv This makes it much more convention to use the initializeFromArgv functions since you can use string literals.
2022-02-01 18:37:31 +00:00
QPDFJob::Config::iiMinBytes(std::string const& parameter)
QPDFJob: convert trivial functions to config API
2022-01-24 00:46:20 +00:00
{
Make QPDFArgParser accept const argv This makes it much more convention to use the initializeFromArgv functions since you can use string literals.
2022-02-01 18:37:31 +00:00
o.m->ii_min_bytes = QUtil::string_to_uint(parameter.c_str());
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
return this;
QPDFJob: convert trivial functions to config API
2022-01-24 00:46:20 +00:00
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
QPDFJob::Config*
QPDFJob: convert trivial functions to config API
2022-01-24 00:46:20 +00:00
QPDFJob::Config::isEncrypted()
{
QPDFJob: move private members into Members
2022-01-26 19:56:24 +00:00
o.m->check_is_encrypted = true;
o.m->require_outfile = false;
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
return this;
QPDFJob: convert trivial functions to config API
2022-01-24 00:46:20 +00:00
}
generate_auto_job: generate overloaded config decls for optional For optional parameter/choices, generate an overloaded config method that takes no arguments. This makes it possible to convert from a bare argument to one that takes an optional parameter without breaking binary compatibility.
2022-02-01 09:16:58 +00:00
QPDFJob::Config*
QPDFJob::Config::json()
{
Make QPDFArgParser accept const argv This makes it much more convention to use the initializeFromArgv functions since you can use string literals.
2022-02-01 18:37:31 +00:00
return json("");
generate_auto_job: generate overloaded config decls for optional For optional parameter/choices, generate an overloaded config method that takes no arguments. This makes it possible to convert from a bare argument to one that takes an optional parameter without breaking binary compatibility.
2022-02-01 09:16:58 +00:00
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
QPDFJob::Config*
Make QPDFArgParser accept const argv This makes it much more convention to use the initializeFromArgv functions since you can use string literals.
2022-02-01 18:37:31 +00:00
QPDFJob::Config::json(std::string const& parameter)
QPDFJob: convert trivial functions to config API
2022-01-24 00:46:20 +00:00
{
Make QPDFArgParser accept const argv This makes it much more convention to use the initializeFromArgv functions since you can use string literals.
2022-02-01 18:37:31 +00:00
if (parameter.empty())
Add optional version to --json
2022-01-31 19:20:06 +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
// The default value is 1 for backward compatibility.
o.m->json_version = 1;
Add optional version to --json
2022-01-31 19:20:06 +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
else if (parameter == "latest")
Add optional version to --json
2022-01-31 19:20:06 +00:00
{
o.m->json_version = 1;
}
Make QPDFArgParser accept const argv This makes it much more convention to use the initializeFromArgv functions since you can use string literals.
2022-02-01 18:37:31 +00:00
else
{
o.m->json_version = QUtil::string_to_int(parameter.c_str());
}
Add optional version to --json
2022-01-31 19:20:06 +00:00
if (o.m->json_version != 1)
{
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
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can'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;
Make QPDFArgParser accept const argv This makes it much more convention to use the initializeFromArgv functions since you can use string literals.
2022-02-01 18:37:31 +00:00
if (parameter == "-")
QPDFJob: move more top-level trivial handlers into config
2022-01-26 00:21:46 +00:00
{
QTC::TC("qpdf", "QPDFJob_config password stdin");
lines = QUtil::read_lines_from_file(std::cin);
}
else
{
QTC::TC("qpdf", "QPDFJob_config password file");
Make QPDFArgParser accept const argv This makes it much more convention to use the initializeFromArgv functions since you can use string literals.
2022-02-01 18:37:31 +00:00
lines = QUtil::read_lines_from_file(parameter.c_str());
QPDFJob: move more top-level trivial handlers into config
2022-01-26 00:21:46 +00:00
}
if (lines.size() >= 1)
{
QPDFJob: move private members into Members
2022-01-26 19:56:24 +00:00
o.m->password = QUtil::make_shared_cstr(lines.front());
QPDFJob: move more top-level trivial handlers into config
2022-01-26 00:21:46 +00:00
if (lines.size() > 1)
{
std::cerr << this->o.m->message_prefix
<< ": WARNING: all but the first line of"
<< " the password file are ignored" << std::endl;
}
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
return this;
QPDFJob: move more top-level trivial handlers into config
2022-01-26 00:21:46 +00:00
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
QPDFJob::Config*
Make QPDFArgParser accept const argv This makes it much more convention to use the initializeFromArgv functions since you can use string literals.
2022-02-01 18:37:31 +00:00
QPDFJob::Config::passwordMode(std::string const& parameter)
QPDFJob: move more top-level trivial handlers into config
2022-01-26 00:21:46 +00:00
{
Make QPDFArgParser accept const argv This makes it much more convention to use the initializeFromArgv functions since you can use string literals.
2022-02-01 18:37:31 +00:00
if (parameter == "bytes")
QPDFJob: move 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->password_mode = QPDFJob::pm_bytes;
QPDFJob: move more top-level trivial handlers into config
2022-01-26 00:21:46 +00:00
}
Make QPDFArgParser accept const argv This makes it much more convention to use the initializeFromArgv functions since you can use string literals.
2022-02-01 18:37:31 +00:00
else if (parameter == "hex-bytes")
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->password_mode = QPDFJob::pm_hex_bytes;
QPDFJob: move more top-level trivial handlers into config
2022-01-26 00:21:46 +00:00
}
Make QPDFArgParser accept const argv This makes it much more convention to use the initializeFromArgv functions since you can use string literals.
2022-02-01 18:37:31 +00:00
else if (parameter == "unicode")
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->password_mode = QPDFJob::pm_unicode;
QPDFJob: move more top-level trivial handlers into config
2022-01-26 00:21:46 +00:00
}
Make QPDFArgParser accept const argv This makes it much more convention to use the initializeFromArgv functions since you can use string literals.
2022-02-01 18:37:31 +00:00
else if (parameter == "auto")
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->password_mode = QPDFJob::pm_auto;
QPDFJob: move more top-level trivial handlers into config
2022-01-26 00:21:46 +00:00
}
else
{
usage("invalid password-mode option");
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
return this;
QPDFJob: move more top-level trivial handlers into config
2022-01-26 00:21:46 +00:00
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
QPDFJob::Config*
Make QPDFArgParser accept const argv This makes it much more convention to use the initializeFromArgv functions since you can use string literals.
2022-02-01 18:37:31 +00:00
QPDFJob::Config::streamData(std::string const& parameter)
QPDFJob: move more top-level trivial handlers into config
2022-01-26 00:21:46 +00:00
{
QPDFJob: move private members into Members
2022-01-26 19:56:24 +00:00
o.m->stream_data_set = true;
Make QPDFArgParser accept const argv This makes it much more convention to use the initializeFromArgv functions since you can use string literals.
2022-02-01 18:37:31 +00:00
if (parameter == "compress")
QPDFJob: move 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_mode = qpdf_s_compress;
QPDFJob: move more top-level trivial handlers into config
2022-01-26 00:21:46 +00:00
}
Make QPDFArgParser accept const argv This makes it much more convention to use the initializeFromArgv functions since you can use string literals.
2022-02-01 18:37:31 +00:00
else if (parameter == "preserve")
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_mode = qpdf_s_preserve;
QPDFJob: move more top-level trivial handlers into config
2022-01-26 00:21:46 +00:00
}
Make QPDFArgParser accept const argv This makes it much more convention to use the initializeFromArgv functions since you can use string literals.
2022-02-01 18:37:31 +00:00
else if (parameter == "uncompress")
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_mode = qpdf_s_uncompress;
QPDFJob: move more top-level trivial handlers into config
2022-01-26 00:21:46 +00:00
}
else
{
usage("invalid stream-data option");
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
return this;
QPDFJob: move more top-level trivial handlers into config
2022-01-26 00:21:46 +00:00
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
QPDFJob::Config*
Make QPDFArgParser accept const argv This makes it much more convention to use the initializeFromArgv functions since you can use string literals.
2022-02-01 18:37:31 +00:00
QPDFJob::Config::decodeLevel(std::string const& parameter)
QPDFJob: move more top-level trivial handlers into config
2022-01-26 00:21:46 +00:00
{
QPDFJob: move private members into Members
2022-01-26 19:56:24 +00:00
o.m->decode_level_set = true;
Make QPDFArgParser accept const argv This makes it much more convention to use the initializeFromArgv functions since you can use string literals.
2022-02-01 18:37:31 +00:00
if (parameter == "none")
QPDFJob: move 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 = qpdf_dl_none;
QPDFJob: move more top-level trivial handlers into config
2022-01-26 00:21:46 +00:00
}
Make QPDFArgParser accept const argv This makes it much more convention to use the initializeFromArgv functions since you can use string literals.
2022-02-01 18:37:31 +00:00
else if (parameter == "generalized")
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 = qpdf_dl_generalized;
QPDFJob: move more top-level trivial handlers into config
2022-01-26 00:21:46 +00:00
}
Make QPDFArgParser accept const argv This makes it much more convention to use the initializeFromArgv functions since you can use string literals.
2022-02-01 18:37:31 +00:00
else if (parameter == "specialized")
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 = qpdf_dl_specialized;
QPDFJob: move more top-level trivial handlers into config
2022-01-26 00:21:46 +00:00
}
Make QPDFArgParser accept const argv This makes it much more convention to use the initializeFromArgv functions since you can use string literals.
2022-02-01 18:37:31 +00:00
else if (parameter == "all")
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 = qpdf_dl_all;
QPDFJob: move more top-level trivial handlers into config
2022-01-26 00:21:46 +00:00
}
else
{
usage("invalid option");
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
return this;
QPDFJob: move more top-level trivial handlers into config
2022-01-26 00:21:46 +00:00
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
QPDFJob::Config*
Make QPDFArgParser accept const argv This makes it much more convention to use the initializeFromArgv functions since you can use string literals.
2022-02-01 18:37:31 +00:00
QPDFJob::Config::objectStreams(std::string const& parameter)
QPDFJob: move more top-level trivial handlers into config
2022-01-26 00:21:46 +00:00
{
QPDFJob: move private members into Members
2022-01-26 19:56:24 +00:00
o.m->object_stream_set = true;
Make QPDFArgParser accept const argv This makes it much more convention to use the initializeFromArgv functions since you can use string literals.
2022-02-01 18:37:31 +00:00
if (parameter == "disable")
QPDFJob: move 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_mode = qpdf_o_disable;
QPDFJob: move more top-level trivial handlers into config
2022-01-26 00:21:46 +00:00
}
Make QPDFArgParser accept const argv This makes it much more convention to use the initializeFromArgv functions since you can use string literals.
2022-02-01 18:37:31 +00:00
else if (parameter == "preserve")
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_mode = qpdf_o_preserve;
QPDFJob: move more top-level trivial handlers into config
2022-01-26 00:21:46 +00:00
}
Make QPDFArgParser accept const argv This makes it much more convention to use the initializeFromArgv functions since you can use string literals.
2022-02-01 18:37:31 +00:00
else if (parameter == "generate")
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_mode = qpdf_o_generate;
QPDFJob: move more top-level trivial handlers into config
2022-01-26 00:21:46 +00:00
}
else
{
usage("invalid object stream mode");
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
return this;
QPDFJob: move more top-level trivial handlers into config
2022-01-26 00:21:46 +00:00
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
QPDFJob::Config*
Make QPDFArgParser accept const argv This makes it much more convention to use the initializeFromArgv functions since you can use string literals.
2022-02-01 18:37:31 +00:00
QPDFJob::Config::removeUnreferencedResources(std::string const& parameter)
QPDFJob: move more top-level trivial handlers into config
2022-01-26 00:21:46 +00:00
{
Make QPDFArgParser accept const argv This makes it much more convention to use the initializeFromArgv functions since you can use string literals.
2022-02-01 18:37:31 +00:00
if (parameter == "auto")
QPDFJob: move 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->remove_unreferenced_page_resources = QPDFJob::re_auto;
QPDFJob: move more top-level trivial handlers into config
2022-01-26 00:21:46 +00:00
}
Make QPDFArgParser accept const argv This makes it much more convention to use the initializeFromArgv functions since you can use string literals.
2022-02-01 18:37:31 +00:00
else if (parameter == "yes")
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->remove_unreferenced_page_resources = QPDFJob::re_yes;
QPDFJob: move more top-level trivial handlers into config
2022-01-26 00:21:46 +00:00
}
Make QPDFArgParser accept const argv This makes it much more convention to use the initializeFromArgv functions since you can use string literals.
2022-02-01 18:37:31 +00:00
else if (parameter == "no")
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->remove_unreferenced_page_resources = QPDFJob::re_no;
QPDFJob: move more top-level trivial handlers into config
2022-01-26 00:21:46 +00:00
}
else
{
usage("invalid value for --remove-unreferenced-page-resources");
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
return this;
QPDFJob: move more top-level trivial handlers into config
2022-01-26 00:21:46 +00:00
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
QPDFJob::Config*
Make QPDFArgParser accept const argv This makes it much more convention to use the initializeFromArgv functions since you can use string literals.
2022-02-01 18:37:31 +00:00
QPDFJob::Config::showObject(std::string const& parameter)
QPDFJob: move more top-level trivial handlers into config
2022-01-26 00:21:46 +00:00
{
QPDFJob: move private members into Members
2022-01-26 19:56:24 +00:00
QPDFJob::parse_object_id(
parameter, o.m->show_trailer, o.m->show_obj, o.m->show_gen);
o.m->require_outfile = false;
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
return this;
QPDFJob: move more top-level trivial handlers into config
2022-01-26 00:21:46 +00:00
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
QPDFJob::Config*
Make QPDFArgParser accept const argv This makes it much more convention to use the initializeFromArgv functions since you can use string literals.
2022-02-01 18:37:31 +00:00
QPDFJob::Config::jobJsonFile(std::string const& parameter)
QPDFJob: move more top-level trivial handlers into config
2022-01-26 00:21:46 +00:00
{
PointerHolder<char> file_buf;
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);
QPDFJob: move more top-level trivial handlers into config
2022-01-26 00:21:46 +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);
QPDFJob: move more top-level trivial handlers into config
2022-01-26 00:21:46 +00:00
}
catch (std::exception& e)
{
throw std::runtime_error(
Fix typo in error message
2022-01-29 17:53:35 +00:00
"error with job-json file " + std::string(parameter) + ": " +
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 +
"--job-json-help for information on the file format.");
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
return this;
QPDFJob: move more top-level trivial handlers into config
2022-01-26 00:21:46 +00:00
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
QPDFJob::Config*
Make QPDFArgParser accept const argv This makes it much more convention to use the initializeFromArgv functions since you can use string literals.
2022-02-01 18:37:31 +00:00
QPDFJob::Config::rotate(std::string const& parameter)
QPDFJob: convert under/overlay and rotate
2022-01-26 14:38:34 +00:00
{
o.parseRotationParameter(parameter);
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
return this;
QPDFJob: convert under/overlay and rotate
2022-01-26 14:38:34 +00:00
}
QPDFJob: convert a flag in other than the main table
2022-01-25 16:07:53 +00:00
std::shared_ptr<QPDFJob::CopyAttConfig>
QPDFJob::Config::copyAttachmentsFrom()
{
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
return std::shared_ptr<CopyAttConfig>(new CopyAttConfig(this));
QPDFJob: convert a flag in other than the main table
2022-01-25 16:07:53 +00:00
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
QPDFJob::CopyAttConfig::CopyAttConfig(Config* c) :
QPDFJob: convert a flag in other than the main table
2022-01-25 16:07:53 +00:00
config(c)
{
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
QPDFJob::CopyAttConfig*
Make QPDFArgParser accept const argv This makes it much more convention to use the initializeFromArgv functions since you can use string literals.
2022-02-01 18:37:31 +00:00
QPDFJob::CopyAttConfig::file(std::string const& parameter)
QPDFJob: convert a flag in other than the main table
2022-01-25 16:07:53 +00:00
{
this->caf.path = parameter;
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
return this;
QPDFJob: convert a flag in other than the main table
2022-01-25 16:07:53 +00:00
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
QPDFJob::CopyAttConfig*
Make QPDFArgParser accept const argv This makes it much more convention to use the initializeFromArgv functions since you can use string literals.
2022-02-01 18:37:31 +00:00
QPDFJob::CopyAttConfig::prefix(std::string const& parameter)
QPDFJob: convert a flag in other than the main table
2022-01-25 16:07:53 +00:00
{
this->caf.prefix = parameter;
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
return this;
QPDFJob: convert a flag in other than the main table
2022-01-25 16:07:53 +00:00
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
QPDFJob::CopyAttConfig*
Make QPDFArgParser accept const argv This makes it much more convention to use the initializeFromArgv functions since you can use string literals.
2022-02-01 18:37:31 +00:00
QPDFJob::CopyAttConfig::password(std::string const& parameter)
QPDFJob: convert a flag in other than the main table
2022-01-25 16:07:53 +00:00
{
this->caf.password = parameter;
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
return this;
QPDFJob: convert a flag in other than the main table
2022-01-25 16:07:53 +00:00
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
QPDFJob::Config*
QPDFJob: use manually named end functions for Config classes Use named functions rather than just end() for clarity.
2022-01-26 22:02:30 +00:00
QPDFJob::CopyAttConfig::endCopyAttachmentsFrom()
QPDFJob: convert a flag in other than the main table
2022-01-25 16:07:53 +00:00
{
if (this->caf.path.empty())
{
Change filename or path to file in json and QPDFJob Use "file" consistently for specifying a file path. We use "filename" when adding attachments for a completely different purpose.
2022-01-31 18:07:19 +00:00
usage("copy attachments: no file specified");
QPDFJob: convert a flag in other than the main table
2022-01-25 16:07:53 +00:00
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
this->config->o.m->attachments_to_copy.push_back(this->caf);
QPDFJob: convert a flag in other than the main table
2022-01-25 16:07:53 +00:00
return this->config;
}
QPDFJob: convert AddAttachment handlers
2022-01-25 21:37:17 +00:00
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
QPDFJob::AttConfig::AttConfig(Config* c) :
QPDFJob: convert AddAttachment handlers
2022-01-25 21:37:17 +00:00
config(c)
{
}
std::shared_ptr<QPDFJob::AttConfig>
QPDFJob::Config::addAttachment()
{
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
return std::shared_ptr<AttConfig>(new AttConfig(this));
QPDFJob: convert AddAttachment handlers
2022-01-25 21:37:17 +00:00
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
QPDFJob::AttConfig*
Make QPDFArgParser accept const argv This makes it much more convention to use the initializeFromArgv functions since you can use string literals.
2022-02-01 18:37:31 +00:00
QPDFJob::AttConfig::file(std::string const& parameter)
QPDFJob: convert AddAttachment handlers
2022-01-25 21:37:17 +00:00
{
this->att.path = parameter;
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
return this;
QPDFJob: convert AddAttachment handlers
2022-01-25 21:37:17 +00:00
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
QPDFJob::AttConfig*
Make QPDFArgParser accept const argv This makes it much more convention to use the initializeFromArgv functions since you can use string literals.
2022-02-01 18:37:31 +00:00
QPDFJob::AttConfig::key(std::string const& parameter)
QPDFJob: convert AddAttachment handlers
2022-01-25 21:37:17 +00:00
{
this->att.key = parameter;
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
return this;
QPDFJob: convert AddAttachment handlers
2022-01-25 21:37:17 +00:00
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
QPDFJob::AttConfig*
Make QPDFArgParser accept const argv This makes it much more convention to use the initializeFromArgv functions since you can use string literals.
2022-02-01 18:37:31 +00:00
QPDFJob::AttConfig::filename(std::string const& parameter)
QPDFJob: convert AddAttachment handlers
2022-01-25 21:37:17 +00:00
{
this->att.filename = parameter;
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
return this;
QPDFJob: convert AddAttachment handlers
2022-01-25 21:37:17 +00:00
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
QPDFJob::AttConfig*
Make QPDFArgParser accept const argv This makes it much more convention to use the initializeFromArgv functions since you can use string literals.
2022-02-01 18:37:31 +00:00
QPDFJob::AttConfig::creationdate(std::string const& parameter)
QPDFJob: convert AddAttachment handlers
2022-01-25 21:37:17 +00:00
{
if (! QUtil::pdf_time_to_qpdf_time(parameter))
{
QPDFJob: move more top-level trivial handlers into config
2022-01-26 00:21:46 +00:00
usage(std::string(parameter) + " is not a valid PDF timestamp");
QPDFJob: convert AddAttachment handlers
2022-01-25 21:37:17 +00:00
}
this->att.creationdate = parameter;
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
return this;
QPDFJob: convert AddAttachment handlers
2022-01-25 21:37:17 +00:00
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
QPDFJob::AttConfig*
Make QPDFArgParser accept const argv This makes it much more convention to use the initializeFromArgv functions since you can use string literals.
2022-02-01 18:37:31 +00:00
QPDFJob::AttConfig::moddate(std::string const& parameter)
QPDFJob: convert AddAttachment handlers
2022-01-25 21:37:17 +00:00
{
if (! QUtil::pdf_time_to_qpdf_time(parameter))
{
QPDFJob: move more top-level trivial handlers into config
2022-01-26 00:21:46 +00:00
usage(std::string(parameter) + " is not a valid PDF timestamp");
QPDFJob: convert AddAttachment handlers
2022-01-25 21:37:17 +00:00
}
this->att.moddate = parameter;
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
return this;
QPDFJob: convert AddAttachment handlers
2022-01-25 21:37:17 +00:00
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
QPDFJob::AttConfig*
Make QPDFArgParser accept const argv This makes it much more convention to use the initializeFromArgv functions since you can use string literals.
2022-02-01 18:37:31 +00:00
QPDFJob::AttConfig::mimetype(std::string const& parameter)
QPDFJob: convert AddAttachment handlers
2022-01-25 21:37:17 +00:00
{
Make QPDFArgParser accept const argv This makes it much more convention to use the initializeFromArgv functions since you can use string literals.
2022-02-01 18:37:31 +00:00
if (parameter.find('/') == std::string::npos)
QPDFJob: convert AddAttachment handlers
2022-01-25 21:37:17 +00:00
{
QPDFJob: move more top-level trivial handlers into config
2022-01-26 00:21:46 +00:00
usage("mime type should be specified as type/subtype");
QPDFJob: convert AddAttachment handlers
2022-01-25 21:37:17 +00:00
}
this->att.mimetype = parameter;
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
return this;
QPDFJob: convert AddAttachment handlers
2022-01-25 21:37:17 +00:00
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
QPDFJob::AttConfig*
Make QPDFArgParser accept const argv This makes it much more convention to use the initializeFromArgv functions since you can use string literals.
2022-02-01 18:37:31 +00:00
QPDFJob::AttConfig::description(std::string const& parameter)
QPDFJob: convert AddAttachment handlers
2022-01-25 21:37:17 +00:00
{
this->att.description = parameter;
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
return this;
QPDFJob: convert AddAttachment handlers
2022-01-25 21:37:17 +00:00
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
QPDFJob::AttConfig*
QPDFJob: convert AddAttachment handlers
2022-01-25 21:37:17 +00:00
QPDFJob::AttConfig::replace()
{
this->att.replace = true;
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
return this;
QPDFJob: convert AddAttachment handlers
2022-01-25 21:37:17 +00:00
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
QPDFJob::Config*
QPDFJob: use manually named end functions for Config classes Use named functions rather than just end() for clarity.
2022-01-26 22:02:30 +00:00
QPDFJob::AttConfig::endAddAttachment()
QPDFJob: convert AddAttachment handlers
2022-01-25 21:37:17 +00:00
{
static std::string now = QUtil::qpdf_time_to_pdf_time(
QUtil::get_current_qpdf_time());
if (this->att.path.empty())
{
Change filename or path to file in json and QPDFJob Use "file" consistently for specifying a file path. We use "filename" when adding attachments for a completely different purpose.
2022-01-31 18:07:19 +00:00
usage("add attachment: no file specified");
QPDFJob: convert AddAttachment handlers
2022-01-25 21:37:17 +00:00
}
std::string last_element = QUtil::path_basename(this->att.path);
if (last_element.empty())
{
Change filename or path to file in json and QPDFJob Use "file" consistently for specifying a file path. We use "filename" when adding attachments for a completely different purpose.
2022-01-31 18:07:19 +00:00
usage("file for --add-attachment may not be empty");
QPDFJob: convert AddAttachment handlers
2022-01-25 21:37:17 +00:00
}
if (this->att.filename.empty())
{
this->att.filename = last_element;
}
if (this->att.key.empty())
{
this->att.key = last_element;
}
if (this->att.creationdate.empty())
{
this->att.creationdate = now;
}
if (this->att.moddate.empty())
{
this->att.moddate = now;
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
this->config->o.m->attachments_to_add.push_back(this->att);
QPDFJob: convert AddAttachment handlers
2022-01-25 21:37:17 +00:00
return this->config;
}
QPDFJob: convert pages
2022-01-26 00:01:10 +00:00
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
QPDFJob::PagesConfig::PagesConfig(Config* c) :
QPDFJob: convert pages
2022-01-26 00:01:10 +00:00
config(c)
{
}
std::shared_ptr<QPDFJob::PagesConfig>
QPDFJob::Config::pages()
{
QPDFJob: move private members into Members
2022-01-26 19:56:24 +00:00
if (! o.m->page_specs.empty())
QPDFJob: eliminate most access to QPDFJob members from ArgParser All that's left now is input and output handling.
2022-01-26 18:39:22 +00:00
{
usage("--pages may only be specified one time");
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
return std::shared_ptr<PagesConfig>(new PagesConfig(this));
QPDFJob: convert pages
2022-01-26 00:01:10 +00:00
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
QPDFJob::Config*
QPDFJob: use manually named end functions for Config classes Use named functions rather than just end() for clarity.
2022-01-26 22:02:30 +00:00
QPDFJob::PagesConfig::endPages()
QPDFJob: convert pages
2022-01-26 00:01:10 +00:00
{
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
if (this->config->o.m->page_specs.empty())
QPDFJob: convert pages
2022-01-26 00:01:10 +00:00
{
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*
QPDFJob: convert pages
2022-01-26 00:01:10 +00:00
QPDFJob::PagesConfig::pageSpec(std::string const& filename,
Minor cleanup
2022-01-26 20:46:02 +00:00
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
{
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
if (config->o.m->under_overlay->filename.empty())
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
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
{
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
if (! config->o.m->under_overlay->filename.empty())
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
usage(config->o.m->under_overlay->which + " file already specified");
QPDFJob: convert under/overlay and rotate
2022-01-26 14:38:34 +00:00
}
else
{
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
config->o.m->under_overlay->filename = parameter;
QPDFJob: convert under/overlay and rotate
2022-01-26 14:38:34 +00:00
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
return this;
QPDFJob: convert under/overlay and rotate
2022-01-26 14:38:34 +00:00
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
QPDFJob::UOConfig*
Make QPDFArgParser accept const argv This makes it much more convention to use the initializeFromArgv functions since you can use string literals.
2022-02-01 18:37:31 +00:00
QPDFJob::UOConfig::to(std::string const& parameter)
QPDFJob: convert under/overlay and rotate
2022-01-26 14:38:34 +00:00
{
Make QPDFArgParser accept const argv This makes it much more convention to use the initializeFromArgv functions since you can use string literals.
2022-02-01 18:37:31 +00:00
config->o.parseNumrange(parameter.c_str(), 0);
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
config->o.m->under_overlay->to_nr = parameter;
return this;
QPDFJob: convert under/overlay and rotate
2022-01-26 14:38:34 +00:00
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
QPDFJob::UOConfig*
Make QPDFArgParser accept const argv This makes it much more convention to use the initializeFromArgv functions since you can use string literals.
2022-02-01 18:37:31 +00:00
QPDFJob::UOConfig::from(std::string const& parameter)
QPDFJob: convert under/overlay and rotate
2022-01-26 14:38:34 +00:00
{
Make QPDFArgParser accept const argv This makes it much more convention to use the initializeFromArgv functions since you can use string literals.
2022-02-01 18:37:31 +00:00
if (! parameter.empty())
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: convert under/overlay and rotate
2022-01-26 14:38:34 +00:00
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
config->o.m->under_overlay->from_nr = parameter;
return this;
QPDFJob: convert under/overlay and rotate
2022-01-26 14:38:34 +00:00
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
QPDFJob::UOConfig*
Make QPDFArgParser accept const argv This makes it much more convention to use the initializeFromArgv functions since you can use string literals.
2022-02-01 18:37:31 +00:00
QPDFJob::UOConfig::repeat(std::string const& parameter)
QPDFJob: convert under/overlay and rotate
2022-01-26 14:38:34 +00:00
{
Make QPDFArgParser accept const argv This makes it much more convention to use the initializeFromArgv functions since you can use string literals.
2022-02-01 18:37:31 +00:00
if (! parameter.empty())
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: convert under/overlay and rotate
2022-01-26 14:38:34 +00:00
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
config->o.m->under_overlay->repeat_nr = parameter;
return this;
QPDFJob: convert under/overlay and rotate
2022-01-26 14:38:34 +00:00
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
QPDFJob::UOConfig*
Make QPDFArgParser accept const argv This makes it much more convention to use the initializeFromArgv functions since you can use string literals.
2022-02-01 18:37:31 +00:00
QPDFJob::UOConfig::password(std::string const& parameter)
QPDFJob: convert under/overlay and rotate
2022-01-26 14:38:34 +00:00
{
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
config->o.m->under_overlay->password = QUtil::make_shared_cstr(parameter);
return this;
QPDFJob: convert under/overlay and rotate
2022-01-26 14:38:34 +00:00
}
QPDFJob: convert encryption handlers
2022-01-26 18:17:57 +00:00
std::shared_ptr<QPDFJob::EncConfig>
QPDFJob::Config::encrypt(int keylen,
std::string const& user_password,
std::string const& owner_password)
{
QPDFJob: move private members into Members
2022-01-26 19:56:24 +00:00
o.m->keylen = keylen;
QPDFJob: convert encryption handlers
2022-01-26 18:17:57 +00:00
if (keylen == 256)
{
QPDFJob: move private members into Members
2022-01-26 19:56:24 +00:00
o.m->use_aes = true;
QPDFJob: convert encryption handlers
2022-01-26 18:17:57 +00:00
}
QPDFJob: move private members into Members
2022-01-26 19:56:24 +00:00
o.m->user_password = user_password;
o.m->owner_password = owner_password;
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
return std::shared_ptr<EncConfig>(new EncConfig(this));
QPDFJob: convert encryption handlers
2022-01-26 18:17:57 +00:00
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
QPDFJob::EncConfig::EncConfig(Config* c) :
QPDFJob: convert encryption handlers
2022-01-26 18:17:57 +00:00
config(c)
{
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
QPDFJob::Config*
QPDFJob: use manually named end functions for Config classes Use named functions rather than just end() for clarity.
2022-01-26 22:02:30 +00:00
QPDFJob::EncConfig::endEncrypt()
QPDFJob: convert encryption handlers
2022-01-26 18:17:57 +00:00
{
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
config->o.m->encrypt = true;
config->o.m->decrypt = false;
config->o.m->copy_encryption = false;
QPDFJob: convert encryption handlers
2022-01-26 18:17:57 +00:00
return this->config;
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
QPDFJob::EncConfig*
QPDFJob: convert encryption handlers
2022-01-26 18:17:57 +00:00
QPDFJob::EncConfig::allowInsecure()
{
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
config->o.m->allow_insecure = true;
return this;
QPDFJob: convert encryption handlers
2022-01-26 18:17:57 +00:00
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
QPDFJob::EncConfig*
Make QPDFArgParser accept const argv This makes it much more convention to use the initializeFromArgv functions since you can use string literals.
2022-02-01 18:37:31 +00:00
QPDFJob::EncConfig::accessibility(std::string const& parameter)
QPDFJob: convert encryption handlers
2022-01-26 18:17:57 +00:00
{
Make QPDFArgParser accept const argv This makes it much more convention to use the initializeFromArgv functions since you can use string literals.
2022-02-01 18:37:31 +00:00
config->o.m->r3_accessibility = (parameter == "y");
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
return this;
QPDFJob: convert encryption handlers
2022-01-26 18:17:57 +00:00
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
QPDFJob::EncConfig*
Make QPDFArgParser accept const argv This makes it much more convention to use the initializeFromArgv functions since you can use string literals.
2022-02-01 18:37:31 +00:00
QPDFJob::EncConfig::extract(std::string const& parameter)
QPDFJob: convert encryption handlers
2022-01-26 18:17:57 +00:00
{
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
if (config->o.m->keylen == 40)
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->r2_extract = (parameter == "y");
QPDFJob: convert encryption handlers
2022-01-26 18:17:57 +00:00
}
else
{
Make QPDFArgParser accept const argv This makes it much more convention to use the initializeFromArgv functions since you can use string literals.
2022-02-01 18:37:31 +00:00
config->o.m->r3_extract = (parameter == "y");
QPDFJob: convert encryption handlers
2022-01-26 18:17:57 +00:00
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
return this;
QPDFJob: convert encryption handlers
2022-01-26 18:17:57 +00:00
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
QPDFJob::EncConfig*
Make QPDFArgParser accept const argv This makes it much more convention to use the initializeFromArgv functions since you can use string literals.
2022-02-01 18:37:31 +00:00
QPDFJob::EncConfig::print(std::string const& parameter)
QPDFJob: convert encryption handlers
2022-01-26 18:17:57 +00:00
{
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
if (config->o.m->keylen == 40)
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->r2_print = (parameter == "y");
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
else if (parameter == "full")
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->r3_print = qpdf_r3p_full;
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
else if (parameter == "low")
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->r3_print = qpdf_r3p_low;
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
else if (parameter == "none")
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->r3_print = qpdf_r3p_none;
QPDFJob: convert encryption handlers
2022-01-26 18:17:57 +00:00
}
else
{
usage("invalid print option");
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
return this;
QPDFJob: convert encryption handlers
2022-01-26 18:17:57 +00:00
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
QPDFJob::EncConfig*
Make QPDFArgParser accept const argv This makes it much more convention to use the initializeFromArgv functions since you can use string literals.
2022-02-01 18:37:31 +00:00
QPDFJob::EncConfig::modify(std::string const& parameter)
QPDFJob: convert encryption handlers
2022-01-26 18:17:57 +00:00
{
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
if (config->o.m->keylen == 40)
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->r2_modify = (parameter == "y");
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
else if (parameter == "all")
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->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;
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
else if (parameter == "annotate")
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->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;
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
else if (parameter == "form")
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->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;
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
else if (parameter == "assembly")
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->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;
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
else if (parameter == "none")
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->r3_assemble = false;
config->o.m->r3_annotate_and_form = false;
config->o.m->r3_form_filling = false;
config->o.m->r3_modify_other = false;
QPDFJob: convert encryption handlers
2022-01-26 18:17:57 +00:00
}
else
{
usage("invalid modify option");
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
return this;
QPDFJob: convert encryption handlers
2022-01-26 18:17:57 +00:00
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
QPDFJob::EncConfig*
QPDFJob: convert encryption handlers
2022-01-26 18:17:57 +00:00
QPDFJob::EncConfig::cleartextMetadata()
{
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
config->o.m->cleartext_metadata = true;
return this;
QPDFJob: convert encryption handlers
2022-01-26 18:17:57 +00:00
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
QPDFJob::EncConfig*
Make QPDFArgParser accept const argv This makes it much more convention to use the initializeFromArgv functions since you can use string literals.
2022-02-01 18:37:31 +00:00
QPDFJob::EncConfig::assemble(std::string const& parameter)
QPDFJob: convert encryption handlers
2022-01-26 18:17:57 +00:00
{
Make QPDFArgParser accept const argv This makes it much more convention to use the initializeFromArgv functions since you can use string literals.
2022-02-01 18:37:31 +00:00
config->o.m->r3_assemble = (parameter == "y");
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
return this;
QPDFJob: convert encryption handlers
2022-01-26 18:17:57 +00:00
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
QPDFJob::EncConfig*
Make QPDFArgParser accept const argv This makes it much more convention to use the initializeFromArgv functions since you can use string literals.
2022-02-01 18:37:31 +00:00
QPDFJob::EncConfig::annotate(std::string const& parameter)
QPDFJob: convert encryption handlers
2022-01-26 18:17:57 +00:00
{
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
if (config->o.m->keylen == 40)
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->r2_annotate = (parameter == "y");
QPDFJob: convert encryption handlers
2022-01-26 18:17:57 +00:00
}
else
{
Make QPDFArgParser accept const argv This makes it much more convention to use the initializeFromArgv functions since you can use string literals.
2022-02-01 18:37:31 +00:00
config->o.m->r3_annotate_and_form = (parameter == "y");
QPDFJob: convert encryption handlers
2022-01-26 18:17:57 +00:00
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
return this;
QPDFJob: convert encryption handlers
2022-01-26 18:17:57 +00:00
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
QPDFJob::EncConfig*
Make QPDFArgParser accept const argv This makes it much more convention to use the initializeFromArgv functions since you can use string literals.
2022-02-01 18:37:31 +00:00
QPDFJob::EncConfig::form(std::string const& parameter)
QPDFJob: convert encryption handlers
2022-01-26 18:17:57 +00:00
{
Make QPDFArgParser accept const argv This makes it much more convention to use the initializeFromArgv functions since you can use string literals.
2022-02-01 18:37:31 +00:00
config->o.m->r3_form_filling = (parameter == "y");
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
return this;
QPDFJob: convert encryption handlers
2022-01-26 18:17:57 +00:00
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
QPDFJob::EncConfig*
Make QPDFArgParser accept const argv This makes it much more convention to use the initializeFromArgv functions since you can use string literals.
2022-02-01 18:37:31 +00:00
QPDFJob::EncConfig::modifyOther(std::string const& parameter)
QPDFJob: convert encryption handlers
2022-01-26 18:17:57 +00:00
{
Make QPDFArgParser accept const argv This makes it much more convention to use the initializeFromArgv functions since you can use string literals.
2022-02-01 18:37:31 +00:00
config->o.m->r3_modify_other = (parameter == "y");
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
return this;
QPDFJob: convert encryption handlers
2022-01-26 18:17:57 +00:00
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
QPDFJob::EncConfig*
Make QPDFArgParser accept const argv This makes it much more convention to use the initializeFromArgv functions since you can use string literals.
2022-02-01 18:37:31 +00:00
QPDFJob::EncConfig::useAes(std::string const& parameter)
QPDFJob: convert encryption handlers
2022-01-26 18:17:57 +00:00
{
Make QPDFArgParser accept const argv This makes it much more convention to use the initializeFromArgv functions since you can use string literals.
2022-02-01 18:37:31 +00:00
config->o.m->use_aes = (parameter == "y");
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
return this;
QPDFJob: convert encryption handlers
2022-01-26 18:17:57 +00:00
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
QPDFJob::EncConfig*
QPDFJob: convert encryption handlers
2022-01-26 18:17:57 +00:00
QPDFJob::EncConfig::forceV4()
{
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
config->o.m->force_V4 = true;
return this;
QPDFJob: convert encryption handlers
2022-01-26 18:17:57 +00:00
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
QPDFJob::EncConfig*
QPDFJob: convert encryption handlers
2022-01-26 18:17:57 +00:00
QPDFJob::EncConfig::forceR5()
{
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with references. Returning pointers instead of references makes for a more uniform interface.
2022-01-26 22:18:03 +00:00
config->o.m->force_R5 = true;
return this;
QPDFJob: convert encryption handlers
2022-01-26 18:17:57 +00:00
}
Copy Permalink