// The contents of this file are in the public domain. See LICENSE_FOR_EXAMPLE_PROGRAMS.txt
/*
This is an example illustrating the use of the compress_stream and
cmd_line_parser components from the dlib C++ Library.
This example implements a simple command line compression utility.
The output from the program when the -h option is given is:
Usage: compress_stream_ex (-c|-d|-l) --in input_file --out output_file
Options:
-c Indicates that we want to compress a file.
-d Indicates that we want to decompress a file.
--in <arg> This option takes one argument which specifies the name of the
file we want to compress/decompress.
--out <arg> This option takes one argument which specifies the name of the
output file.
Miscellaneous Options:
-h Display this help message.
-l <arg> Set the compression level [1-3], 3 is max compression, default
is 2.
*/
#include <dlib/compress_stream.h>
#include <dlib/cmd_line_parser.h>
#include <iostream>
#include <fstream>
#include <string>
// I am making a typedefs for the versions of compress_stream I want to use.
typedef dlib::compress_stream::kernel_1da cs1;
typedef dlib::compress_stream::kernel_1ea cs2;
typedef dlib::compress_stream::kernel_1ec cs3;
using namespace std;
using namespace dlib;
int main(int argc, char** argv)
{
try
{
command_line_parser parser;
// first I will define the command line options I want.
// Add a -c option and tell the parser what the option is for.
parser.add_option("c","Indicates that we want to compress a file.");
parser.add_option("d","Indicates that we want to decompress a file.");
// add a --in option that takes 1 argument
parser.add_option("in","This option takes one argument which specifies the name of the file we want to compress/decompress.",1);
// add a --out option that takes 1 argument
parser.add_option("out","This option takes one argument which specifies the name of the output file.",1);
// In the code below, we use the parser.print_options() method to print all our
// options to the screen. We can tell it that we would like some options to be
// grouped together by calling set_group_name() before adding those options. In
// general, you can make as many groups as you like by calling set_group_name().
// However, here we make only one named group.
parser.set_group_name("Miscellaneous Options");
parser.add_option("h","Display this help message.");
parser.add_option("l","Set the compression level [1-3], 3 is max compression, default is 2.",1);
// now I will parse the command line
parser.parse(argc,argv);
// Now I will use the parser to validate some things about the command line.
// If any of the following checks fail then an exception will be thrown and it will
// contain a message that tells the user what the problem was.
// First I want to check that none of the options were given on the command line
// more than once. To do this I define an array that contains the options
// that shouldn't appear more than once and then I just call check_one_time_options()
const char* one_time_opts[] = {"c", "d", "in", "out", "h", "l"};
parser.check_one_time_options(one_time_opts);
// Here I'm checking that the user didn't pick both the c and d options at the
// same time.
parser.check_incompatible_options("c", "d");
// Here I'm checking that the argument to the l option is an integer in the range 1 to 3.
// That is, it should be convertible to an int by dlib::string_assign and be either
// 1, 2, or 3. Note that if you wanted to allow floating point values in the range 1 to
// 3 then you could give a range 1.0 to 3.0 or explicitly supply a type of float or double
// to the template argument of the check_option_arg_range() function.
parser.check_option_arg_range("l", 1, 3);
// The 'l' option is a sub-option of the 'c' option. That is, you can only select the
// compression level when compressing. This command below checks that the listed
// sub options are always given in the presence of their parent options.
const char* c_sub_opts[] = {"l"};
parser.check_sub_options("c", c_sub_opts);
// check if the -h option was given on the command line
if (parser.option("h"))
{
// display all the command line options
cout << "Usage: compress_stream_ex (-c|-d|-l) --in input_file --out output_file\n";
// This function prints out a nicely formatted list of
// all the options the parser has
parser.print_options();
return 0;
}
// Figure out what the compression level should be. If the user didn't supply
// this command line option then a value of 2 will be used.
int compression_level = get_option(parser,"l",2);
// make sure one of the c or d options was given
if (!parser.option("c") && !parser.option("d"))
{
cout << "Error in command line:\n You must specify either the c option or the d option.\n";
cout << "\nTry the -h option for more information." << endl;
return 0;
}
string in_file;
string out_file;
// check if the user told us the input file and if they did then
// get the file name
if (parser.option("in"))
{
in_file = parser.option("in").argument();
}
else
{
cout << "Error in command line:\n You must specify an input file.\n";
cout << "\nTry the -h option for more information." << endl;
return 0;
}
// check if the user told us the output file and if they did then
// get the file name
if (parser.option("out"))
{
out_file = parser.option("out").argument();
}
else
{
cout << "Error in command line:\n You must specify an output file.\n";
cout << "\nTry the -h option for more information." << endl;
return 0;
}
// open the files we will be reading from and writing to
ifstream fin(in_file.c_str(),ios::binary);
ofstream fout(out_file.c_str(),ios::binary);
// make sure the files opened correctly
if (!fin)
{
cout << "Error opening file " << in_file << ".\n";
return 0;
}
if (!fout)
{
cout << "Error creating file " << out_file << ".\n";
return 0;
}
// now perform the actual compression or decompression.
if (parser.option("c"))
{
// save the compression level to the output file
serialize(compression_level, fout);
switch (compression_level)
{
case 1:
{
cs1 compressor;
compressor.compress(fin,fout);
}break;
case 2:
{
cs2 compressor;
compressor.compress(fin,fout);
}break;
case 3:
{
cs3 compressor;
compressor.compress(fin,fout);
}break;
}
}
else
{
// obtain the compression level from the input file
deserialize(compression_level, fin);
switch (compression_level)
{
case 1:
{
cs1 compressor;
compressor.decompress(fin,fout);
}break;
case 2:
{
cs2 compressor;
compressor.decompress(fin,fout);
}break;
case 3:
{
cs3 compressor;
compressor.decompress(fin,fout);
}break;
default:
{
cout << "Error in compressed file, invalid compression level" << endl;
}break;
}
}
}
catch (exception& e)
{
// Note that this will catch any cmd_line_parse_error exceptions and print
// the default message.
cout << e.what() << endl;
}
}