Martchus
/
tageditor
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Fix bugs in cli

This commit is contained in:
Martchus 2016-06-25 23:11:16 +02:00
parent 0e488ddcd2
commit f394dcb46b
3 changed files with 170 additions and 167 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
application/main.cpp
View File

@ -103,7 +103,7 @@ SetTagInfoArgs::SetTagInfoArgs(Argument &filesArg, Argument &verboseArg) :
valuesArg.setRequiredValueCount(-1); valuesArg.setRequiredValueCount(-1);
valuesArg.setImplicit(true); valuesArg.setImplicit(true);
setTagInfoArg.setDenotesOperation(true); setTagInfoArg.setDenotesOperation(true);
setTagInfoArg.setCallback(std::bind(Cli::setTagInfo, _1, std::cref(*this))); setTagInfoArg.setCallback(std::bind(Cli::setTagInfo, std::cref(*this)));
setTagInfoArg.setSubArguments({&valuesArg, &filesArg, &docTitleArg, &removeOtherFieldsArg, &treatUnknownFilesAsMp3FilesArg, &id3v1UsageArg, &id3v2UsageArg, setTagInfoArg.setSubArguments({&valuesArg, &filesArg, &docTitleArg, &removeOtherFieldsArg, &treatUnknownFilesAsMp3FilesArg, &id3v1UsageArg, &id3v2UsageArg,
&mergeMultipleSuccessiveTagsArg, &id3v2VersionArg, &encodingArg, &removeTargetsArg, &attachmentsArg, &mergeMultipleSuccessiveTagsArg, &id3v2VersionArg, &encodingArg, &removeTargetsArg, &attachmentsArg,
&removeExistingAttachmentsArg, &minPaddingArg, &maxPaddingArg, &prefPaddingArg, &tagPosArg, &removeExistingAttachmentsArg, &minPaddingArg, &maxPaddingArg, &prefPaddingArg, &tagPosArg,
@ -155,7 +155,7 @@ int main(int argc, char *argv[])
fieldsArg.setImplicit(true); fieldsArg.setImplicit(true);
Argument displayTagInfoArg("get", 'g', "displays the values of all specified tag fields (displays all fields if none specified)"); Argument displayTagInfoArg("get", 'g', "displays the values of all specified tag fields (displays all fields if none specified)");
displayTagInfoArg.setDenotesOperation(true); displayTagInfoArg.setDenotesOperation(true);
displayTagInfoArg.setCallback(std::bind(Cli::displayTagInfo, _1, std::cref(filesArg), std::cref(verboseArg))); displayTagInfoArg.setCallback(std::bind(Cli::displayTagInfo, std::cref(fieldsArg), std::cref(filesArg), std::cref(verboseArg)));
displayTagInfoArg.setSubArguments({&fieldsArg, &filesArg, &verboseArg}); displayTagInfoArg.setSubArguments({&fieldsArg, &filesArg, &verboseArg});
// set tag info // set tag info
Cli::SetTagInfoArgs setTagInfoArgs(filesArg, verboseArg); Cli::SetTagInfoArgs setTagInfoArgs(filesArg, verboseArg);
@ -167,7 +167,7 @@ int main(int argc, char *argv[])
Argument extractFieldArg("extract", 'e', "extracts the specified field from the specified file"); Argument extractFieldArg("extract", 'e', "extracts the specified field from the specified file");
extractFieldArg.setSubArguments({&fieldArg, &fileArg, &outputFileArg, &verboseArg}); extractFieldArg.setSubArguments({&fieldArg, &fileArg, &outputFileArg, &verboseArg});
extractFieldArg.setDenotesOperation(true); extractFieldArg.setDenotesOperation(true);
extractFieldArg.setCallback(std::bind(Cli::extractField, _1, std::cref(fileArg), std::cref(outputFileArg), std::cref(verboseArg))); extractFieldArg.setCallback(std::bind(Cli::extractField, std::cref(fieldsArg), std::cref(fileArg), std::cref(outputFileArg), std::cref(verboseArg)));
// file info // file info
Argument validateArg("validate", 'c', "validates the file integrity as accurately as possible; the structure of the file will be parsed completely"); Argument validateArg("validate", 'c', "validates the file integrity as accurately as possible; the structure of the file will be parsed completely");
validateArg.setCombinable(true); validateArg.setCombinable(true);

115
cli/mainfeatures.cpp
View File

@ -285,16 +285,18 @@ bool applyTargetConfiguration(TagTarget &target, const std::string &configStr)
} }
} }
vector<FieldDenotation> parseFieldDenotations(const std::vector<const char *> &fieldDenotations, bool readOnly) vector<FieldDenotation> parseFieldDenotations(const Argument &fieldsArg, bool readOnly)
{ {
vector<FieldDenotation> fields; vector<FieldDenotation> fields;
if(fieldsArg.isPresent()) {
const vector<const char *> &fieldDenotations = fieldsArg.values();
fields.reserve(fieldDenotations.size()); fields.reserve(fieldDenotations.size());
TagType currentTagType = TagType::Unspecified; TagType currentTagType = TagType::Unspecified;
TagTarget currentTagTarget; TagTarget currentTagTarget;
for(const char *fieldDenotationString : fieldDenotations) { for(const char *fieldDenotationString : fieldDenotations) {
// check for tag or target specifier // check for tag or target specifier
const auto fieldDenotationLen = strlen(fieldDenotationString); const auto fieldDenotationLen = strlen(fieldDenotationString);
if(strncmp(fieldDenotationString, "tag:", 4) == 0) { if(!strncmp(fieldDenotationString, "tag:", 4)) {
if(fieldDenotationLen == 4) { if(fieldDenotationLen == 4) {
cerr << "Warning: The \"tag\"-specifier has been used with no value(s) and hence is ignored. Possible values are: id3,id3v1,id3v2,itunes,vorbis,matroska,all" << endl; cerr << "Warning: The \"tag\"-specifier has been used with no value(s) and hence is ignored. Possible values are: id3,id3v1,id3v2,itunes,vorbis,matroska,all" << endl;
} else { } else {
@ -329,19 +331,18 @@ vector<FieldDenotation> parseFieldDenotations(const std::vector<const char *> &f
} }
// read field name // read field name
const auto equationPos = strchr(fieldDenotationString, '='); const auto equationPos = strchr(fieldDenotationString, '=');
auto fieldName = equationPos ? string(fieldDenotationString, static_cast<size_t>(equationPos - fieldDenotationString)) : fieldDenotationString; size_t fieldNameLen = equationPos ? static_cast<size_t>(equationPos - fieldDenotationString) : strlen(fieldDenotationString);
// field name might denote increment ("+") or path disclosure (">") // field name might denote increment ("+") or path disclosure (">")
auto fieldNamePos = fieldName.size();
DenotationType type = DenotationType::Normal; DenotationType type = DenotationType::Normal;
if(fieldNamePos) { if(fieldNameLen && equationPos) {
switch(fieldName.at(--fieldNamePos)) { switch(*(equationPos - 1)) {
case '+': case '+':
type = DenotationType::Increment; type = DenotationType::Increment;
--fieldNamePos; --fieldNameLen;
break; break;
case '>': case '>':
type = DenotationType::File; type = DenotationType::File;
--fieldNamePos; --fieldNameLen;
break; break;
default: default:
; ;
@ -349,75 +350,73 @@ vector<FieldDenotation> parseFieldDenotations(const std::vector<const char *> &f
} }
// field name might specify a file index // field name might specify a file index
unsigned int fileIndex = 0, mult = 1; unsigned int fileIndex = 0, mult = 1;
for(; fieldNamePos != static_cast<string::size_type>(-1) && isDigit(fieldName.at(fieldNamePos)); --fieldNamePos, mult *= 10) { for(const char *digitPos = fieldDenotationString + fieldNameLen - 1; fieldNameLen && isDigit(*digitPos); --fieldNameLen, --digitPos, mult *= 10) {
fileIndex += static_cast<unsigned int>(fieldName.at(fieldNamePos) - '0') * mult; fileIndex += static_cast<unsigned int>(*digitPos - '0') * mult;
} }
if(fieldNamePos == static_cast<string::size_type>(-1)) { if(!fieldNameLen) {
cerr << "Warning: Ignoring field denotation \"" << fieldDenotationString << "\" because no field name has been specified." << endl; cerr << "Warning: Ignoring field denotation \"" << fieldDenotationString << "\" because no field name has been specified." << endl;
continue; continue;
} else if(++fieldNamePos < fieldName.size()) {
fieldName = string(fieldName, fieldNamePos);
} }
// parse the denoted filed // parse the denoted filed
KnownField field; KnownField field;
if(fieldName == "title") { if(!strncmp(fieldDenotationString, "title", fieldNameLen)) {
field = KnownField::Title; field = KnownField::Title;
} else if(fieldName == "album") { } else if(!strncmp(fieldDenotationString, "album", fieldNameLen)) {
field = KnownField::Album; field = KnownField::Album;
} else if(fieldName == "artist") { } else if(!strncmp(fieldDenotationString, "artist", fieldNameLen)) {
field = KnownField::Artist; field = KnownField::Artist;
} else if(fieldName == "genre") { } else if(!strncmp(fieldDenotationString, "genre", fieldNameLen)) {
field = KnownField::Genre; field = KnownField::Genre;
} else if(fieldName == "year") { } else if(!strncmp(fieldDenotationString, "year", fieldNameLen)) {
field = KnownField::Year; field = KnownField::Year;
} else if(fieldName == "comment") { } else if(!strncmp(fieldDenotationString, "comment", fieldNameLen)) {
field = KnownField::Comment; field = KnownField::Comment;
} else if(fieldName == "bpm") { } else if(!strncmp(fieldDenotationString, "bpm", fieldNameLen)) {
field = KnownField::Bpm; field = KnownField::Bpm;
} else if(fieldName == "bps") { } else if(!strncmp(fieldDenotationString, "bps", fieldNameLen)) {
field = KnownField::Bps; field = KnownField::Bps;
} else if(fieldName == "lyricist") { } else if(!strncmp(fieldDenotationString, "lyricist", fieldNameLen)) {
field = KnownField::Lyricist; field = KnownField::Lyricist;
} else if(fieldName == "track") { } else if(!strncmp(fieldDenotationString, "track", fieldNameLen)) {
field = KnownField::TrackPosition; field = KnownField::TrackPosition;
} else if(fieldName == "disk") { } else if(!strncmp(fieldDenotationString, "disk", fieldNameLen)) {
field = KnownField::DiskPosition; field = KnownField::DiskPosition;
} else if(fieldName == "part") { } else if(!strncmp(fieldDenotationString, "part", fieldNameLen)) {
field = KnownField::PartNumber; field = KnownField::PartNumber;
} else if(fieldName == "totalparts") { } else if(!strncmp(fieldDenotationString, "totalparts", fieldNameLen)) {
field = KnownField::TotalParts; field = KnownField::TotalParts;
} else if(fieldName == "encoder") { } else if(!strncmp(fieldDenotationString, "encoder", fieldNameLen)) {
field = KnownField::Encoder; field = KnownField::Encoder;
} else if(fieldName == "recorddate") { } else if(!strncmp(fieldDenotationString, "recorddate", fieldNameLen)) {
field = KnownField::RecordDate; field = KnownField::RecordDate;
} else if(fieldName == "performers") { } else if(!strncmp(fieldDenotationString, "performers", fieldNameLen)) {
field = KnownField::Performers; field = KnownField::Performers;
} else if(fieldName == "duration") { } else if(!strncmp(fieldDenotationString, "duration", fieldNameLen)) {
field = KnownField::Length; field = KnownField::Length;
} else if(fieldName == "language") { } else if(!strncmp(fieldDenotationString, "language", fieldNameLen)) {
field = KnownField::Language; field = KnownField::Language;
} else if(fieldName == "encodersettings") { } else if(!strncmp(fieldDenotationString, "encodersettings", fieldNameLen)) {
field = KnownField::EncoderSettings; field = KnownField::EncoderSettings;
} else if(fieldName == "lyrics") { } else if(!strncmp(fieldDenotationString, "lyrics", fieldNameLen)) {
field = KnownField::Lyrics; field = KnownField::Lyrics;
} else if(fieldName == "synchronizedlyrics") { } else if(!strncmp(fieldDenotationString, "synchronizedlyrics", fieldNameLen)) {
field = KnownField::SynchronizedLyrics; field = KnownField::SynchronizedLyrics;
} else if(fieldName == "grouping") { } else if(!strncmp(fieldDenotationString, "grouping", fieldNameLen)) {
field = KnownField::Grouping; field = KnownField::Grouping;
} else if(fieldName == "recordlabel") { } else if(!strncmp(fieldDenotationString, "recordlabel", fieldNameLen)) {
field = KnownField::RecordLabel; field = KnownField::RecordLabel;
} else if(fieldName == "cover") { } else if(!strncmp(fieldDenotationString, "cover", fieldNameLen)) {
field = KnownField::Cover; field = KnownField::Cover;
type = DenotationType::File; // read cover always from file type = DenotationType::File; // read cover always from file
} else if(fieldName == "composer") { } else if(!strncmp(fieldDenotationString, "composer", fieldNameLen)) {
field = KnownField::Composer; field = KnownField::Composer;
} else if(fieldName == "rating") { } else if(!strncmp(fieldDenotationString, "rating", fieldNameLen)) {
field = KnownField::Rating; field = KnownField::Rating;
} else if(fieldName == "description") { } else if(!strncmp(fieldDenotationString, "description", fieldNameLen)) {
field = KnownField::Description; field = KnownField::Description;
} else { } else {
// no "KnownField" value matching -> discard the field denotation // no "KnownField" value matching -> discard the field denotation
cerr << "Warning: The field name \"" << fieldName << "\" is unknown and will be ingored." << endl; cerr << "Warning: The field name \"" << string(fieldDenotationString, fieldNameLen) << "\" is unknown and will be ingored." << endl;
continue; continue;
} }
// add field denotation with parsed values // add field denotation with parsed values
@ -428,12 +427,13 @@ vector<FieldDenotation> parseFieldDenotations(const std::vector<const char *> &f
fieldDenotation.tagTarget = currentTagTarget; fieldDenotation.tagTarget = currentTagTarget;
if(equationPos) { if(equationPos) {
if(readOnly) { if(readOnly) {
cerr << "Warning: Specified value for \"" << fieldName << "\" will be ignored." << endl; cerr << "Warning: Specified value for \"" << string(fieldDenotationString, fieldNameLen) << "\" will be ignored." << endl;
} else { } else {
fieldDenotation.values.emplace_back(make_pair(mult == 1 ? fieldDenotation.values.size() : fileIndex, QString::fromLocal8Bit(equationPos + 1))); fieldDenotation.values.emplace_back(make_pair(mult == 1 ? fieldDenotation.values.size() : fileIndex, QString::fromLocal8Bit(equationPos + 1)));
} }
} }
} }
}
return fields; return fields;
} }
@ -645,7 +645,7 @@ void printProperty(const char *propName, const intType value, const char *suffix
void displayFileInfo(const std::vector<const char *> &, const Argument &filesArg, const Argument &verboseArg) void displayFileInfo(const std::vector<const char *> &, const Argument &filesArg, const Argument &verboseArg)
{ {
CMD_UTILS_START_CONSOLE; CMD_UTILS_START_CONSOLE;
if(filesArg.values().empty()) { if(!filesArg.isPresent() || filesArg.values().empty()) {
cout << "Error: No files have been specified." << endl; cout << "Error: No files have been specified." << endl;
return; return;
} }
@ -770,14 +770,14 @@ void displayFileInfo(const std::vector<const char *> &, const Argument &filesArg
} }
} }
void displayTagInfo(const std::vector<const char *> &parameterValues, const Argument &filesArg, const Argument &verboseArg) void displayTagInfo(const Argument &fieldsArg, const Argument &filesArg, const Argument &verboseArg)
{ {
CMD_UTILS_START_CONSOLE; CMD_UTILS_START_CONSOLE;
if(filesArg.values().empty()) { if(!filesArg.isPresent() || filesArg.values().empty()) {
cout << "Error: No files have been specified." << endl; cout << "Error: No files have been specified." << endl;
return; return;
} }
const auto fields = parseFieldDenotations(parameterValues, true); const auto fields = parseFieldDenotations(fieldsArg, true);
MediaFileInfo fileInfo; MediaFileInfo fileInfo;
for(const auto &file : filesArg.values()) { for(const auto &file : filesArg.values()) {
try { try {
@ -869,14 +869,14 @@ void displayTagInfo(const std::vector<const char *> &parameterValues, const Argu
} }
} }
void setTagInfo(const std::vector<const char *> &parameterValues, const SetTagInfoArgs &args) void setTagInfo(const SetTagInfoArgs &args)
{ {
CMD_UTILS_START_CONSOLE; CMD_UTILS_START_CONSOLE;
if(args.setTagInfoArg.values().empty()) { if(!args.filesArg.isPresent() || args.filesArg.values().empty()) {
cerr << "Error: No files have been specified." << endl; cerr << "Error: No files have been specified." << endl;
return; return;
} }
auto fields = parseFieldDenotations(parameterValues, false); auto fields = parseFieldDenotations(args.valuesArg, false);
if(fields.empty() && args.attachmentsArg.values().empty() && args.docTitleArg.values().empty()) { if(fields.empty() && args.attachmentsArg.values().empty() && args.docTitleArg.values().empty()) {
cerr << "Error: No fields/attachments have been specified." << endl; cerr << "Error: No fields/attachments have been specified." << endl;
return; return;
@ -892,6 +892,7 @@ void setTagInfo(const std::vector<const char *> &parameterValues, const SetTagIn
vector<TagTarget> targetsToRemove; vector<TagTarget> targetsToRemove;
targetsToRemove.emplace_back(); targetsToRemove.emplace_back();
bool validRemoveTargetsSpecified = false; bool validRemoveTargetsSpecified = false;
if(args.removeTargetsArg.isPresent()) {
for(const auto &targetDenotation : args.removeTargetsArg.values()) { for(const auto &targetDenotation : args.removeTargetsArg.values()) {
if(!strcmp(targetDenotation, ",")) { if(!strcmp(targetDenotation, ",")) {
if(validRemoveTargetsSpecified) { if(validRemoveTargetsSpecified) {
@ -903,6 +904,7 @@ void setTagInfo(const std::vector<const char *> &parameterValues, const SetTagIn
cerr << "Warning: The given target specification \"" << targetDenotation << "\" is invalid and will be ignored." << endl; cerr << "Warning: The given target specification \"" << targetDenotation << "\" is invalid and will be ignored." << endl;
} }
} }
}
// parse other settings // parse other settings
uint32 id3v2Version = 3; uint32 id3v2Version = 3;
if(args.id3v2VersionArg.isPresent()) { if(args.id3v2VersionArg.isPresent()) {
@ -955,7 +957,7 @@ void setTagInfo(const std::vector<const char *> &parameterValues, const SetTagIn
fileInfo.createAppropriateTags(args.treatUnknownFilesAsMp3FilesArg.isPresent(), id3v1Usage, id3v2Usage, args.mergeMultipleSuccessiveTagsArg.isPresent(), !args.id3v2VersionArg.isPresent(), id3v2Version, requiredTargets); fileInfo.createAppropriateTags(args.treatUnknownFilesAsMp3FilesArg.isPresent(), id3v1Usage, id3v2Usage, args.mergeMultipleSuccessiveTagsArg.isPresent(), !args.id3v2VersionArg.isPresent(), id3v2Version, requiredTargets);
auto container = fileInfo.container(); auto container = fileInfo.container();
bool docTitleModified = false; bool docTitleModified = false;
if(!args.docTitleArg.values().empty()) { if(args.docTitleArg.isPresent() && !args.docTitleArg.values().empty()) {
if(container && container->supportsTitle()) { if(container && container->supportsTitle()) {
size_t segmentIndex = 0, segmentCount = container->titles().size(); size_t segmentIndex = 0, segmentCount = container->titles().size();
for(const auto &newTitle : args.docTitleArg.values()) { for(const auto &newTitle : args.docTitleArg.values()) {
@ -1100,20 +1102,21 @@ void setTagInfo(const std::vector<const char *> &parameterValues, const SetTagIn
} else { } else {
cerr << "Warning: No changed to be applied." << endl; cerr << "Warning: No changed to be applied." << endl;
} }
} catch(const ios_base::failure &) {
cerr << "Error: An IO failure occured when reading/writing the file \"" << file << "\"." << endl;
} catch(const ApplicationUtilities::Failure &) { } catch(const ApplicationUtilities::Failure &) {
cerr << "Error: A parsing failure occured when reading/writing the file \"" << file << "\"." << endl; cerr << "Error: A parsing failure occured when reading/writing the file \"" << file << "\"." << endl;
} catch(...) {
::IoUtilities::catchIoFailure();
cerr << "Error: An IO failure occured when reading/writing the file \"" << file << "\"." << endl;
} }
printNotifications(notifications, "Notifications:", args.verboseArg.isPresent()); printNotifications(notifications, "Notifications:", args.verboseArg.isPresent());
++fileIndex; ++fileIndex;
} }
} }
void extractField(const std::vector<const char *> &parameterValues, const Argument &inputFileArg, const Argument &outputFileArg, const Argument &verboseArg) void extractField(const Argument &fieldsArg, const Argument &inputFileArg, const Argument &outputFileArg, const Argument &verboseArg)
{ {
CMD_UTILS_START_CONSOLE; CMD_UTILS_START_CONSOLE;
const auto fields = parseFieldDenotations(parameterValues, true); const auto fields = parseFieldDenotations(fieldsArg, true);
if(fields.size() != 1) { if(fields.size() != 1) {
cerr << "Error: Excactly one field needs to be specified." << endl; cerr << "Error: Excactly one field needs to be specified." << endl;
return; return;
@ -1124,7 +1127,7 @@ void extractField(const std::vector<const char *> &parameterValues, const Argume
inputFileInfo.setPath(inputFileArg.values().front()); inputFileInfo.setPath(inputFileArg.values().front());
inputFileInfo.open(true); inputFileInfo.open(true);
inputFileInfo.parseTags(); inputFileInfo.parseTags();
cout << "Extracting " << parameterValues.front() << " of \"" << inputFileArg.values().front() << "\" ..." << endl; cout << "Extracting " << fieldsArg.values().front() << " of \"" << inputFileArg.values().front() << "\" ..." << endl;
auto tags = inputFileInfo.tags(); auto tags = inputFileInfo.tags();
vector<pair<const TagValue *, string> > values; vector<pair<const TagValue *, string> > values;
// iterate through all tags // iterate through all tags
@ -1137,7 +1140,7 @@ void extractField(const std::vector<const char *> &parameterValues, const Argume
} }
} }
if(values.empty()) { if(values.empty()) {
cerr << "File has no (supported) " << parameterValues.front() << " field." << endl; cerr << "File has no (supported) " << fieldsArg.values().front() << " field." << endl;
} else { } else {
string outputFilePathWithoutExtension, outputFileExtension; string outputFilePathWithoutExtension, outputFileExtension;
if(values.size() > 1) { if(values.size() > 1) {

6
cli/mainfeatures.h
View File

@ -46,9 +46,9 @@ struct SetTagInfoArgs
void printFieldNames(const std::vector<const char *> &parameterValues); void printFieldNames(const std::vector<const char *> &parameterValues);
void displayFileInfo(const std::vector<const char *> &, const ApplicationUtilities::Argument &filesArg, const ApplicationUtilities::Argument &verboseArg); void displayFileInfo(const std::vector<const char *> &, const ApplicationUtilities::Argument &filesArg, const ApplicationUtilities::Argument &verboseArg);
void generateFileInfo(const std::vector<const char *> &parameterValues, const ApplicationUtilities::Argument &inputFileArg, const ApplicationUtilities::Argument &outputFileArg, const ApplicationUtilities::Argument &validateArg); void generateFileInfo(const std::vector<const char *> &parameterValues, const ApplicationUtilities::Argument &inputFileArg, const ApplicationUtilities::Argument &outputFileArg, const ApplicationUtilities::Argument &validateArg);
void displayTagInfo(const std::vector<const char *> &parameterValues, const ApplicationUtilities::Argument &filesArg, const ApplicationUtilities::Argument &verboseArg); void displayTagInfo(const ApplicationUtilities::Argument &fieldsArg, const ApplicationUtilities::Argument &filesArg, const ApplicationUtilities::Argument &verboseArg);
void setTagInfo(const std::vector<const char *> &parameterValues, const Cli::SetTagInfoArgs &args); void setTagInfo(const Cli::SetTagInfoArgs &args);
void extractField(const std::vector<const char *> &parameterValues, const ApplicationUtilities::Argument &inputFileArg, const ApplicationUtilities::Argument &outputFileArg, const ApplicationUtilities::Argument &verboseArg); void extractField(const ApplicationUtilities::Argument &fieldsArg, const ApplicationUtilities::Argument &inputFileArg, const ApplicationUtilities::Argument &outputFileArg, const ApplicationUtilities::Argument &verboseArg);
void removeBackupFiles(const std::vector<const char *> &parameterValues, const ApplicationUtilities::Argument &recursiveArg); void removeBackupFiles(const std::vector<const char *> &parameterValues, const ApplicationUtilities::Argument &recursiveArg);
} }