octoleo/qpdf
2
1
Fork 0
mirror of https://github.com/qpdf/qpdf.git synced 2024-11-04 20:37:50 +00:00
Code Issues Releases Wiki Activity
cd30f626fe
qpdf/libqpdf/QPDFJob_config.cc

1219 lines
25 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>
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: convert trivial functions to config API
2022-01-24 00:46:20 +00:00
#include <cstring>
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*
QPDFJob: move input/output handling into config
2022-01-26 18:56:13 +00:00
QPDFJob::Config::inputFile(char const* filename)
{
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
{
// QXXXQ decide whether to fix this or just leave the comment:
// 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*
QPDFJob: move input/output handling into config
2022-01-26 18:56:13 +00:00
QPDFJob::Config::outputFile(char const* filename)
{
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
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't 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::collate(char const* parameter)
{
auto n = ((parameter == 0) ? 1 :
QUtil::string_to_uint(parameter));
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*
QPDFJob: convert trivial functions to config API
2022-01-24 00:46:20 +00:00
QPDFJob::Config::compressStreams(char const* parameter)
{
QPDFJob: move private members into Members
2022-01-26 19:56:24 +00:00
o.m->compress_streams_set = true;
o.m->compress_streams = (strcmp(parameter, "y") == 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
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::compressionLevel(char const* parameter)
{
QPDFJob: move private members into Members
2022-01-26 19:56:24 +00:00
o.m->compression_level = QUtil::string_to_int(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::copyEncryption(char const* parameter)
{
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*
QPDFJob: convert trivial functions to config API
2022-01-24 00:46:20 +00:00
QPDFJob::Config::encryptionFilePassword(char const* parameter)
{
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*
QPDFJob: convert trivial functions to config API
2022-01-24 00:46:20 +00:00
QPDFJob::Config::flattenAnnotations(char const* parameter)
{
QPDFJob: move private members into Members
2022-01-26 19:56:24 +00:00
o.m->flatten_annotations = true;
QPDFJob: convert trivial functions to config API
2022-01-24 00:46:20 +00:00
if (strcmp(parameter, "screen") == 0)
{
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
}
else if (strcmp(parameter, "print") == 0)
{
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
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't do with 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*
QPDFJob: convert trivial functions to config API
2022-01-24 00:46:20 +00:00
QPDFJob::Config::forceVersion(char const* parameter)
{
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*
QPDFJob: convert trivial functions to config API
2022-01-24 00:46:20 +00:00
QPDFJob::Config::iiMinBytes(char const* parameter)
{
QPDFJob: move private members into Members
2022-01-26 19:56:24 +00:00
o.m->ii_min_bytes = QUtil::string_to_uint(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::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
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't 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::json()
{
QPDFJob: move private members into Members
2022-01-26 19:56:24 +00:00
o.m->json = 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::jsonKey(char const* parameter)
{
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*
QPDFJob: convert trivial functions to config API
2022-01-24 00:46:20 +00:00
QPDFJob::Config::jsonObject(char const* parameter)
{
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*
QPDFJob: convert trivial functions to config API
2022-01-24 00:46:20 +00:00
QPDFJob::Config::keepFilesOpen(char const* parameter)
{
QPDFJob: move private members into Members
2022-01-26 19:56:24 +00:00
o.m->keep_files_open_set = true;
o.m->keep_files_open = (strcmp(parameter, "y") == 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
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::keepFilesOpenThreshold(char const* parameter)
{
QPDFJob: move private members into Members
2022-01-26 19:56:24 +00:00
o.m->keep_files_open_threshold = QUtil::string_to_uint(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::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*
QPDFJob: convert trivial functions to config API
2022-01-24 00:46:20 +00:00
QPDFJob::Config::linearizePass1(char const* parameter)
{
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*
QPDFJob: convert trivial functions to config API
2022-01-24 00:46:20 +00:00
QPDFJob::Config::minVersion(char const* parameter)
{
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*
QPDFJob: convert trivial functions to config API
2022-01-24 00:46:20 +00:00
QPDFJob::Config::normalizeContent(char const* parameter)
{
QPDFJob: move private members into Members
2022-01-26 19:56:24 +00:00
o.m->normalize_set = true;
o.m->normalize = (strcmp(parameter, "y") == 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
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::oiMinArea(char const* parameter)
{
QPDFJob: make remaining members private
2022-01-26 21:40:14 +00:00
o.m->oi_min_area = QUtil::string_to_uint(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::oiMinHeight(char const* parameter)
{
QPDFJob: make remaining members private
2022-01-26 21:40:14 +00:00
o.m->oi_min_height = QUtil::string_to_uint(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::oiMinWidth(char const* parameter)
{
QPDFJob: make remaining members private
2022-01-26 21:40:14 +00:00
o.m->oi_min_width = QUtil::string_to_uint(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::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*
QPDFJob: convert password in two tables
2022-01-25 16:14:43 +00:00
QPDFJob::Config::password(char const* parameter)
{
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*
QPDFJob: convert trivial functions to config API
2022-01-24 00:46:20 +00:00
QPDFJob::Config::removeAttachment(char const* parameter)
{
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*
QPDFJob: convert trivial functions to config API
2022-01-24 00:46:20 +00:00
QPDFJob::Config::showAttachment(char const* parameter)
{
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
}
QPDFJob: use pointers instead of references for Config Why? The main methods that create them return smart pointers so that users can initialize them when needed, which you can't 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::splitPages(char const* parameter)
{
int n = ((parameter == 0) ? 1 :
QUtil::string_to_int(parameter));
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*
QPDFJob: move more top-level trivial handlers into config
2022-01-26 00:21:46 +00:00
QPDFJob::Config::passwordFile(char const* parameter)
{
std::list<std::string> lines;
if (strcmp(parameter, "-") == 0)
{
QTC::TC("qpdf", "QPDFJob_config password stdin");
lines = QUtil::read_lines_from_file(std::cin);
}
else
{
QTC::TC("qpdf", "QPDFJob_config password file");
lines = QUtil::read_lines_from_file(parameter);
}
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*
QPDFJob: move more top-level trivial handlers into config
2022-01-26 00:21:46 +00:00
QPDFJob::Config::passwordMode(char const* parameter)
{
if (strcmp(parameter, "bytes") == 0)
{
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
}
else if (strcmp(parameter, "hex-bytes") == 0)
{
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
}
else if (strcmp(parameter, "unicode") == 0)
{
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
}
else if (strcmp(parameter, "auto") == 0)
{
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*
QPDFJob: move more top-level trivial handlers into config
2022-01-26 00:21:46 +00:00
QPDFJob::Config::streamData(char const* parameter)
{
QPDFJob: move private members into Members
2022-01-26 19:56:24 +00:00
o.m->stream_data_set = true;
QPDFJob: move more top-level trivial handlers into config
2022-01-26 00:21:46 +00:00
if (strcmp(parameter, "compress") == 0)
{
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
}
else if (strcmp(parameter, "preserve") == 0)
{
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
}
else if (strcmp(parameter, "uncompress") == 0)
{
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
{
// If this happens, it means streamDataChoices in
// ArgParser::initOptionTable is wrong.
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*
QPDFJob: move more top-level trivial handlers into config
2022-01-26 00:21:46 +00:00
QPDFJob::Config::decodeLevel(char const* parameter)
{
QPDFJob: move private members into Members
2022-01-26 19:56:24 +00:00
o.m->decode_level_set = true;
QPDFJob: move more top-level trivial handlers into config
2022-01-26 00:21:46 +00:00
if (strcmp(parameter, "none") == 0)
{
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
}
else if (strcmp(parameter, "generalized") == 0)
{
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
}
else if (strcmp(parameter, "specialized") == 0)
{
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
}
else if (strcmp(parameter, "all") == 0)
{
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
{
// If this happens, it means decodeLevelChoices in
// ArgParser::initOptionTable is wrong.
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*
QPDFJob: move more top-level trivial handlers into config
2022-01-26 00:21:46 +00:00
QPDFJob::Config::objectStreams(char const* parameter)
{
QPDFJob: move private members into Members
2022-01-26 19:56:24 +00:00
o.m->object_stream_set = true;
QPDFJob: move more top-level trivial handlers into config
2022-01-26 00:21:46 +00:00
if (strcmp(parameter, "disable") == 0)
{
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
}
else if (strcmp(parameter, "preserve") == 0)
{
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
}
else if (strcmp(parameter, "generate") == 0)
{
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
{
// If this happens, it means objectStreamsChoices in
// ArgParser::initOptionTable is wrong.
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*
QPDFJob: move more top-level trivial handlers into config
2022-01-26 00:21:46 +00:00
QPDFJob::Config::removeUnreferencedResources(char const* parameter)
{
if (strcmp(parameter, "auto") == 0)
{
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
}
else if (strcmp(parameter, "yes") == 0)
{
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
}
else if (strcmp(parameter, "no") == 0)
{
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
{
// If this happens, it means remove_unref_choices in
// ArgParser::initOptionTable is wrong.
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*
QPDFJob: move more top-level trivial handlers into config
2022-01-26 00:21:46 +00:00
QPDFJob::Config::showObject(char const* parameter)
{
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*
QPDFJob: move more top-level trivial handlers into config
2022-01-26 00:21:46 +00:00
QPDFJob::Config::jobJsonFile(char const* parameter)
{
PointerHolder<char> file_buf;
size_t size;
QUtil::read_file_into_memory(parameter, file_buf, size);
try
{
o.initializeFromJson(std::string(file_buf.getPointer(), size));
}
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*
QPDFJob: convert under/overlay and rotate
2022-01-26 14:38:34 +00:00
QPDFJob::Config::rotate(char const* parameter)
{
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*
QPDFJob: convert AddAttachment handlers
2022-01-25 21:37:17 +00:00
QPDFJob::CopyAttConfig::path(char 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*
QPDFJob: convert a flag in other than the main table
2022-01-25 16:07:53 +00:00
QPDFJob::CopyAttConfig::prefix(char const* parameter)
{
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*
QPDFJob: convert a flag in other than the main table
2022-01-25 16:07:53 +00:00
QPDFJob::CopyAttConfig::password(char const* parameter)
{
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())
{
QPDFJob: move more top-level trivial handlers into config
2022-01-26 00:21:46 +00:00
usage("copy attachments: no path 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*
QPDFJob: convert AddAttachment handlers
2022-01-25 21:37:17 +00:00
QPDFJob::AttConfig::path(char const* parameter)
{
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*
QPDFJob: convert AddAttachment handlers
2022-01-25 21:37:17 +00:00
QPDFJob::AttConfig::key(char const* parameter)
{
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*
QPDFJob: convert AddAttachment handlers
2022-01-25 21:37:17 +00:00
QPDFJob::AttConfig::filename(char const* parameter)
{
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*
QPDFJob: convert AddAttachment handlers
2022-01-25 21:37:17 +00:00
QPDFJob::AttConfig::creationdate(char const* parameter)
{
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*
QPDFJob: convert AddAttachment handlers
2022-01-25 21:37:17 +00:00
QPDFJob::AttConfig::moddate(char const* parameter)
{
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*
QPDFJob: convert AddAttachment handlers
2022-01-25 21:37:17 +00:00
QPDFJob::AttConfig::mimetype(char const* parameter)
{
if (strchr(parameter, '/') == nullptr)
{
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*
QPDFJob: convert AddAttachment handlers
2022-01-25 21:37:17 +00:00
QPDFJob::AttConfig::description(char const* parameter)
{
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())
{
QPDFJob: move more top-level trivial handlers into config
2022-01-26 00:21:46 +00:00
usage("add attachment: no path 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())
{
QPDFJob: move more top-level trivial handlers into config
2022-01-26 00:21:46 +00:00
usage("path 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*
QPDFJob: convert under/overlay and rotate
2022-01-26 14:38:34 +00:00
QPDFJob::UOConfig::path(char const* 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
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*
QPDFJob: convert under/overlay and rotate
2022-01-26 14:38:34 +00:00
QPDFJob::UOConfig::to(char const* 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
config->o.parseNumrange(parameter, 0);
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*
QPDFJob: convert under/overlay and rotate
2022-01-26 14:38:34 +00:00
QPDFJob::UOConfig::from(char const* parameter)
{
if (strlen(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
config->o.parseNumrange(parameter, 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*
QPDFJob: convert under/overlay and rotate
2022-01-26 14:38:34 +00:00
QPDFJob::UOConfig::repeat(char const* parameter)
{
if (strlen(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
config->o.parseNumrange(parameter, 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*
QPDFJob: convert under/overlay and rotate
2022-01-26 14:38:34 +00:00
QPDFJob::UOConfig::password(char const* 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
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*
QPDFJob: convert encryption handlers
2022-01-26 18:17:57 +00:00
QPDFJob::EncConfig::accessibility(char const* 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
config->o.m->r3_accessibility = (strcmp(parameter, "y") == 0);
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::extract(char const* 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
if (config->o.m->keylen == 40)
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->r2_extract = (strcmp(parameter, "y") == 0);
QPDFJob: convert encryption handlers
2022-01-26 18:17:57 +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->r3_extract = (strcmp(parameter, "y") == 0);
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*
QPDFJob: convert encryption handlers
2022-01-26 18:17:57 +00:00
QPDFJob::EncConfig::print(char const* 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
if (config->o.m->keylen == 40)
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->r2_print = (strcmp(parameter, "y") == 0);
QPDFJob: convert encryption handlers
2022-01-26 18:17:57 +00:00
}
else if (strcmp(parameter, "full") == 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->r3_print = qpdf_r3p_full;
QPDFJob: convert encryption handlers
2022-01-26 18:17:57 +00:00
}
else if (strcmp(parameter, "low") == 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->r3_print = qpdf_r3p_low;
QPDFJob: convert encryption handlers
2022-01-26 18:17:57 +00:00
}
else if (strcmp(parameter, "none") == 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->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*
QPDFJob: convert encryption handlers
2022-01-26 18:17:57 +00:00
QPDFJob::EncConfig::modify(char const* 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
if (config->o.m->keylen == 40)
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->r2_modify = (strcmp(parameter, "y") == 0);
QPDFJob: convert encryption handlers
2022-01-26 18:17:57 +00:00
}
else if (strcmp(parameter, "all") == 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->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
}
else if (strcmp(parameter, "annotate") == 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->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
}
else if (strcmp(parameter, "form") == 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->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
}
else if (strcmp(parameter, "assembly") == 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->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
}
else if (strcmp(parameter, "none") == 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->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*
QPDFJob: convert encryption handlers
2022-01-26 18:17:57 +00:00
QPDFJob::EncConfig::assemble(char const* 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
config->o.m->r3_assemble = (strcmp(parameter, "y") == 0);
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::annotate(char const* 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
if (config->o.m->keylen == 40)
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->r2_annotate = (strcmp(parameter, "y") == 0);
QPDFJob: convert encryption handlers
2022-01-26 18:17:57 +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->r3_annotate_and_form = (strcmp(parameter, "y") == 0);
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*
QPDFJob: convert encryption handlers
2022-01-26 18:17:57 +00:00
QPDFJob::EncConfig::form(char const* 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
config->o.m->r3_form_filling = (strcmp(parameter, "y") == 0);
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::modifyOther(char const* 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
config->o.m->r3_modify_other = (strcmp(parameter, "y") == 0);
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::useAes(char const* 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
config->o.m->use_aes = (strcmp(parameter, "y") == 0);
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