.. _program_listing_file__tmp_ws_src_ecl_core_ecl_command_line_include_ecl_command_line_std_output.hpp:

Program Listing for File std_output.hpp
=======================================

|exhale_lsh| :ref:`Return to documentation for file <file__tmp_ws_src_ecl_core_ecl_command_line_include_ecl_command_line_std_output.hpp>` (``/tmp/ws/src/ecl_core/ecl_command_line/include/ecl/command_line/std_output.hpp``)

.. |exhale_lsh| unicode:: U+021B0 .. UPWARDS ARROW WITH TIP LEFTWARDS

.. code-block:: cpp

   
   /*****************************************************************************
   ** Ifdefs
   *****************************************************************************/
   
   #ifndef TCLAP_STDCMDLINEOUTPUT_H
   #define TCLAP_STDCMDLINEOUTPUT_H
   
   #include <string>
   #include <vector>
   #include <list>
   #include <iostream>
   #include <algorithm>
   #include <cmath>
   
   #include "cmd_line_interface.hpp"
   #include "cmd_line_output.hpp"
   #include "xor_handler.hpp"
   #include "arg.hpp"
   
   namespace ecl {
   
   class StdOutput : public CmdLineOutput
   {
   
       public:
   
           virtual void usage(CmdLineInterface& c);
   
           virtual void version(CmdLineInterface& c);
   
           virtual void failure(CmdLineInterface& c,
                                ArgException& e );
   
       protected:
   
           void _shortUsage( CmdLineInterface& c, std::ostream& os ) const;
   
           void _longUsage( CmdLineInterface& c, std::ostream& os ) const;
   
           void spacePrint( std::ostream& os,
                            const std::string& s,
                            int maxWidth,
                            int indentSpaces,
                            int secondLineOffset ) const;
   
   };
   
   
   inline void StdOutput::version(CmdLineInterface& _cmd)
   {
       std::string progName = _cmd.getProgramName();
       std::string interface_version = _cmd.getVersion();
   
       std::cout << std::endl << progName << "  version: "
                 << interface_version << std::endl << std::endl;
   }
   
   inline void StdOutput::usage(CmdLineInterface& _cmd )
   {
       std::cout << std::endl << "USAGE: " << std::endl << std::endl;
   
       _shortUsage( _cmd, std::cout );
   
       std::cout << std::endl << std::endl << "Where: " << std::endl << std::endl;
   
       _longUsage( _cmd, std::cout );
   
       std::cout << std::endl;
   
   }
   
   inline void StdOutput::failure( CmdLineInterface& _cmd,
                                   ArgException& e )
   {
       std::string progName = _cmd.getProgramName();
   
       std::cerr << "PARSE ERROR: " << e.argId() << std::endl
                 << "             " << e.error() << std::endl << std::endl;
   
       if ( _cmd.hasHelpAndVersion() )
       {
           std::cerr << "Brief USAGE: " << std::endl;
   
           _shortUsage( _cmd, std::cerr );
   
           std::cerr << std::endl << "For complete USAGE and HELP type: "
                     << std::endl << "   " << progName << " --help"
                     << std::endl << std::endl;
       }
       else
           usage(_cmd);
   
   }
   
   inline void StdOutput::_shortUsage( CmdLineInterface& _cmd,
                                       std::ostream& os ) const
   {
       std::list<Arg*> argList = _cmd.getArgList();
       std::string progName = _cmd.getProgramName();
       XorHandler xorHandler = _cmd.getXorHandler();
       std::vector< std::vector<Arg*> > xorList = xorHandler.getXorList();
   
       std::string s = progName + " ";
   
       // first the xor
       for ( int i = 0; static_cast<unsigned int>(i) < xorList.size(); i++ )
       {
           s += " {";
           for ( ArgVectorIterator it = xorList[i].begin();
                           it != xorList[i].end(); it++ )
               s += (*it)->shortID() + "|";
   
           s[s.length()-1] = '}';
       }
   
       // then the rest
       for (ArgListIterator it = argList.begin(); it != argList.end(); it++)
           if ( !xorHandler.contains( (*it) ) )
               s += " " + (*it)->shortID();
   
       // if the program name is too long, then adjust the second line offset
       int secondLineOffset = static_cast<int>(progName.length()) + 2;
       if ( secondLineOffset > 75/2 )
               secondLineOffset = static_cast<int>(75/2);
   
       spacePrint( os, s, 75, 3, secondLineOffset );
       //spacePrint( std::cout, s, 75, 3, secondLineOffset );
   }
   
   inline void StdOutput::_longUsage( CmdLineInterface& _cmd,
                                      std::ostream& os ) const
   {
       std::list<Arg*> argList = _cmd.getArgList();
       std::string message = _cmd.getMessage();
       XorHandler xorHandler = _cmd.getXorHandler();
       std::vector< std::vector<Arg*> > xorList = xorHandler.getXorList();
   
       // first the xor
       for ( int i = 0; static_cast<unsigned int>(i) < xorList.size(); i++ )
       {
           for ( ArgVectorIterator it = xorList[i].begin();
                 it != xorList[i].end();
                 it++ )
           {
               spacePrint( os, (*it)->longID(), 75, 3, 3 );
               spacePrint( os, (*it)->getDescription(), 75, 5, 0 );
   
               if ( it+1 != xorList[i].end() )
                   spacePrint(os, "-- OR --", 75, 9, 0);
           }
           os << std::endl << std::endl;
       }
   
       // then the rest
       for (ArgListIterator it = argList.begin(); it != argList.end(); it++)
           if ( !xorHandler.contains( (*it) ) )
           {
               spacePrint( os, (*it)->longID(), 75, 3, 3 );
               spacePrint( os, (*it)->getDescription(), 75, 5, 0 );
               os << std::endl;
           }
   
       os << std::endl;
   
       spacePrint( os, message, 75, 3, 0 );
   }
   
   inline void StdOutput::spacePrint( std::ostream& os,
                                      const std::string& s,
                                      int maxWidth,
                                      int indentSpaces,
                                      int secondLineOffset ) const
   {
       int len = static_cast<int>(s.length());
   
       if ( (len + indentSpaces > maxWidth) && maxWidth > 0 )
       {
           int allowedLen = maxWidth - indentSpaces;
           int start = 0;
           while ( start < len )
           {
               // find the substring length
             int stringLen = std::min<int>( len - start, allowedLen );
   
               // trim the length so it doesn't end in middle of a word
               if ( stringLen == allowedLen )
                   while ( s[stringLen+start] != ' ' &&
                           s[stringLen+start] != ',' &&
                           s[stringLen+start] != '|' &&
                           stringLen >= 0 )
                       stringLen--;
   
               // ok, the word is longer than the line, so just split
               // wherever the line ends
               if ( stringLen <= 0 )
                   stringLen = allowedLen;
   
               // check for newlines
               for ( int i = 0; i < stringLen; i++ )
                   if ( s[start+i] == '\n' )
                       stringLen = i+1;
   
               // print the indent
               for ( int i = 0; i < indentSpaces; i++ )
                   os << " ";
   
               if ( start == 0 )
               {
                   // handle second line offsets
                   indentSpaces += secondLineOffset;
   
                   // adjust allowed len
                   allowedLen -= secondLineOffset;
               }
   
               os << s.substr(start,stringLen) << std::endl;
   
               // so we don't start a line with a space
               while ( s[stringLen+start] == ' ' && start < len )
                   start++;
   
               start += stringLen;
           }
       }
       else
       {
           for ( int i = 0; i < indentSpaces; i++ )
                   os << " ";
           os << s << std::endl;
       }
   }
   } // namespace ecl
   
   #endif