cmdStdOutput.h

Go to the documentation of this file.

/****************************************************************************** 
 * 
 *  file:  StdOutput.h
 * 
 *  Copyright (c) 2004, Michael E. Smoot
 *  All rights reverved.
 * 
 *  See the file COPYING in the top directory of this distribution for
 *  more information.
 *  
 *  THE SOFTWARE IS PROVIDED _AS IS_, WITHOUT WARRANTY OF ANY KIND, EXPRESS 
 *  OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
 *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 
 *  THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 
 *  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING 
 *  FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER 
 *  DEALINGS IN THE SOFTWARE.  
 *  
 *****************************************************************************/ 

#ifndef DtCmdLine_STDCMDLINEOUTPUT_H
#define DtCmdLine_STDCMDLINEOUTPUT_H


#include <string>
#include <vector>
#include <list>
#include <iostream>
#include <algorithm>
#include <vlutil/vlPrint.h>
#include <vlutil/vlProcessControl.h>

#include "cmdLineInterface.h"
#include "cmdLineOutput.h"
#include "cmdXorHandler.h"
#include "cmdArg.h"

#ifdef DtUSE_UTILITIES_NAMESPACE
namespace DtUSE_UTILITIES_NAMESPACE
{
#endif

   namespace DtCmdLine {


      class StdOutput : public CmdLineOutput
      {

      public:

         virtual ~StdOutput() { }

         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 version = _cmd.getVersion();

         int oldNotifyLevel = DtNotifyLevel;
         DtNotifyLevel = 3;
         DtInfo 
            << '\n' << progName << "  version: " 
            << version << "\n\n";
         DtNotifyLevel = oldNotifyLevel;
      }

      inline void StdOutput::usage(CmdLineInterface& _cmd ) 
      {
         int oldNotifyLevel = DtNotifyLevel;
         DtNotifyLevel = 3;
         DtInfo << '\n' << "USAGE: " << '\n' << '\n'; 

         _shortUsage( _cmd, DtInfo );

         DtInfo << '\n' << "Where: " << '\n';

         _longUsage( _cmd, DtInfo );

         DtInfo << std::endl; 
         DtNotifyLevel = oldNotifyLevel;

      }

      inline void StdOutput::failure( CmdLineInterface& _cmd, ArgException& e ) 
      {
         int oldNotifyLevel = DtNotifyLevel;
         DtNotifyLevel = 4;
         std::string progName = _cmd.getProgramName();

         DtWarn 
            << "PARSE ERROR: " << e.argId() << '\n'
            << "             " << e.error() << "\n\n"
            << "Brief USAGE: " << '\n';

         _shortUsage( _cmd, DtWarn );  

         DtWarn 
            << '\n' << "For complete USAGE and HELP type: " 
            << '\n' << "   " << progName << " --help" 
            << '\n' << std::endl;
         DtNotifyLevel = oldNotifyLevel;

      }

      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 + " ";

         for ( int i = 0; (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] = '}';
         }

         for (ArgListIterator it = argList.begin(); it != argList.end(); it++)
            if ( !xorHandler.contains( (*it) ) )
               s += " " + (*it)->shortID();

         int secondLineOffset = (int)(progName.length()) + 2;
         if ( secondLineOffset > 80/2 )
            secondLineOffset = (int)(80/2);

         spacePrint( os, s, 80, 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();

         for ( int i = 0; (unsigned int)i < xorList.size(); i++ )
         {
            for ( ArgVectorIterator it = xorList[i].begin(); 
                  it != xorList[i].end(); 
                  it++ )
            {
               spacePrint( os, (*it)->longID(), 80, 3, 3 );
               spacePrint( os, (*it)->getDescription(), 80, 12, 0 );

               if ( it+1 != xorList[i].end() )
                  spacePrint(os, "-- OR --", 80, 25, 0);
            }
         }

         for (ArgListIterator it = argList.begin(); it != argList.end(); it++)
         {
            if ( !xorHandler.contains( (*it) ) )
            {
               spacePrint( os, (*it)->longID(), 80, 3, 3 ); 
               spacePrint( os, (*it)->getDescription(), 80, 12, 0 ); 
            }
         }
         os << '\n';
         spacePrint( os, message, 80, 3, 0 );
      }

      inline void StdOutput::spacePrint( std::ostream& os, 
                                         const std::string& s, 
                                         int maxWidth, 
                                         int indentSpaces, 
                                         int secondLineOffset ) const
      {
         int len = (int)(s.length());

         if ( (len + indentSpaces > maxWidth) && maxWidth > 0 )
         {
            int allowedLen = maxWidth - indentSpaces;
            int start = 0;
            while ( start < len )
            {
#ifdef _WIN32
               int stringLen = ( len - start < allowedLen ? len - start : allowedLen);
#else
               int stringLen = std::min( len - start, allowedLen );
#endif

               if ( stringLen == allowedLen )
                  while ( s[stringLen+start] != ' ' && 
                          s[stringLen+start] != ',' &&
                          s[stringLen+start] != '|' &&
                          stringLen >= 0 )
                     stringLen--;

               if ( stringLen <= 0 )
                  stringLen = allowedLen;

               int i  = 0;
               for (i = 0; i < stringLen; i++ )
                  if ( s[start+i] == '\n' )
                     stringLen = i+1;

               for (i = 0; i < indentSpaces; i++ )
                  os << " ";

               if ( start == 0 )
               {
                  indentSpaces += secondLineOffset;

                  allowedLen -= secondLineOffset;
               }

               os << s.substr(start,stringLen) << std::endl;

               while ( s[stringLen+start] == ' ' && start < len )
                  start++;

               start += stringLen;
            }
         }
         else
         {
            for ( int i = 0; i < indentSpaces; i++ )
               os << " ";
            os << s << std::endl;
         }
      }

   } //namespace DtCmdLine

#ifdef DtUSE_UTILITIES_NAMESPACE
}     
#endif

#endif