    // Copyright (C) 2005  Davis E. King (davis@dlib.net)
    // License: Boost Software License   See LICENSE.txt for the full license.
    #ifndef DLIB_CMD_LINE_PARSER_PRINt_1_
    #define DLIB_CMD_LINE_PARSER_PRINt_1_

    #include "cmd_line_parser_kernel_abstract.h"
    #include "../algs.h"
    #include "../string.h"
    #include <iostream>
    #include <string>
    #include <sstream>
    #include <map>
    #include "../smart_pointers.h"

    namespace dlib
    {

        template <
            typename clp_base
            >
        class cmd_line_parser_print_1 : public clp_base
        {

            public:

                void print_options (
                    std::basic_ostream<typename clp_base::char_type>& out
                ) const;

                void print_options (
                ) const
                {
                    print_options(std::cout);
                }

        };

        template <
            typename clp_base
            >
        inline void swap (
            cmd_line_parser_print_1<clp_base>& a,
            cmd_line_parser_print_1<clp_base>& b
        ) { a.swap(b); }

    // ----------------------------------------------------------------------------------------
    // ----------------------------------------------------------------------------------------
        // member function definitions
    // ----------------------------------------------------------------------------------------
    // ----------------------------------------------------------------------------------------

        template <
            typename clp_base
            >
        void cmd_line_parser_print_1<clp_base>::
        print_options (
            std::basic_ostream<typename clp_base::char_type>& out
        ) const
        {
            typedef typename clp_base::char_type ct;
            typedef std::basic_string<ct> string;
            typedef typename string::size_type size_type;

            typedef std::basic_ostringstream<ct> ostringstream;

            try
            {

                size_type max_len = 0;
                this->reset();

                // this loop here is just the bottom loop but without the print statements.
                // I'm doing this to figure out what len should be.
                while (this->move_next())
                {
                    size_type len = 0;
                    len += 3;
                    if (this->element().name().size() > 1)
                    {
                        ++len;
                    }
                    len += this->element().name().size();

                    if (this->element().number_of_arguments() == 1)
                    {
                        len += 6;
                    }
                    else
                    {
                        for (unsigned long i = 0; i < this->element().number_of_arguments(); ++i)
                        {
                            len += 7;
                            if (i+1 > 9)
                                ++len;
                        }
                    }

                    len += 3;
                    if (len < 33)
                        max_len = std::max(max_len,len);
                }

                // Make a separate ostringstream for each option group.  We are going to write
                // the output for each group to a separate ostringstream so that we can keep
                // them grouped together in the final output.
                std::map<string,shared_ptr<ostringstream> > groups;
                this->reset();
                while(this->move_next())
                {
                    if (!groups[this->element().group_name()])
                        groups[this->element().group_name()].reset(new ostringstream);
                }

                this->reset();

                while (this->move_next())
                {
                    ostringstream& sout = *groups[this->element().group_name()];

                    size_type len = 0;
                    sout << _dT(ct,"\n  -");
                    len += 3;
                    if (this->element().name().size() > 1)
                    {
                        sout << _dT(ct,"-");
                        ++len;
                    }
                    sout << this->element().name();
                    len += this->element().name().size();

                    if (this->element().number_of_arguments() == 1)
                    {
                        sout << _dT(ct," <arg>");
                        len += 6;
                    }
                    else
                    {
                        for (unsigned long i = 0; i < this->element().number_of_arguments(); ++i)
                        {
                            sout << _dT(ct," <arg") << i+1 << _dT(ct,">");
                            len += 7;
                            if (i+1 > 9)
                                ++len;
                        }
                    }

                    sout << _dT(ct,"   ");
                    len += 3;

                    while (len < max_len)
                    {
                        ++len;
                        sout << _dT(ct," ");
                    }

                    const unsigned long ml = static_cast<unsigned long>(max_len);
                    // now print the description but make it wrap around nicely if it
                    // is to long to fit on one line.
                    if (len <= max_len)
                        sout << wrap_string(this->element().description(),0,ml);
                    else
                        sout << _dT(ct,"\n") << wrap_string(this->element().description(),ml,ml);
                }

                // Only print out a generic Options: group name if there is an unnamed option
                // present.
                if (groups.count(string()) == 1)
                    out << _dT(ct,"Options:");

                // Now print everything out
                typename std::map<string,shared_ptr<ostringstream> >::iterator i;
                for (i = groups.begin(); i != groups.end(); ++i)
                {
                    // print the group name if we have one
                    if (i->first.size() != 0)
                    {
                        if (i != groups.begin())
                            out << _dT(ct,"\n\n");
                        out << i->first << _dT(ct,":");
                    }

                    // print the options in the group
                    out << i->second->str();
                }
                out << _dT(ct,"\n\n");
                this->reset();
            }
            catch (...)
            {
                this->reset();
                throw;
            }
        }

    // ----------------------------------------------------------------------------------------

    }

    #endif // DLIB_CMD_LINE_PARSER_PRINt_1_