ProgArg.h

Go to the documentation of this file.

/********************************************************************
**                Image Component Library (ICL)                    **
**                                                                 **
** Copyright (C) 2006-2013 CITEC, University of Bielefeld          **
**                         Neuroinformatics Group                  **
** Website: www.iclcv.org and                                      **
**          http://opensource.cit-ec.de/projects/icl               **
**                                                                 **
** File   : ICLUtils/src/ICLUtils/ProgArg.h                        **
** Module : ICLUtils                                               **
** Authors: Christof Elbrechter, Andre Justus                      **
**                                                                 **
**                                                                 **
** GNU LESSER GENERAL PUBLIC LICENSE                               **
** This file may be used under the terms of the GNU Lesser General **
** Public License version 3.0 as published by the                  **
**                                                                 **
** Free Software Foundation and appearing in the file LICENSE.GPL  **
** included in the packaging of this file.  Please review the      **
** following information to ensure the license requirements will   **
** be met: http://www.gnu.org/licenses/lgpl-3.0.txt                **
**                                                                 **
** The development of this software was supported by the           **
** Excellence Cluster EXC 277 Cognitive Interaction Technology.    **
** The Excellence Cluster EXC 277 is a grant of the Deutsche       **
** Forschungsgemeinschaft (DFG) in the context of the German       **
** Excellence Initiative.                                          **
**                                                                 **
********************************************************************/

#pragma once

#include <ICLUtils/Any.h>
#include <ICLUtils/Exception.h>
#include <ICLUtils/Macros.h>

namespace icl{
  namespace utils{
  
    struct ProgArgException : public ICLException{
      ProgArgException(const std::string &func, const std::string &what):
      ICLException(func+":"+what){}
    };
  #define THROW_ProgArgException(X) throw ProgArgException(__FUNCTION__,(X))
    
    // internally used programm argument data type
    class ProgArgData{
      protected:
      friend const std::string &pa_subarg_internal(const ProgArgData &pa) throw (ProgArgException);
      friend bool pa_defined_internal(const ProgArgData &pa) throw (ProgArgException);
      std::string id;
      int subargidx;
      bool danglingOnly;
      inline ProgArgData(const std::string &id, int subargidx):
        id(id),subargidx((int)subargidx){
      }
      inline ProgArgData(unsigned int idx, bool danglingOnly):
        subargidx(idx),danglingOnly(danglingOnly){
      }
        
    };
    // internal function for program argument explanation
    void pa_explain_internal(const std::string &pa, const std::string &ex);
    
    // internal sub-argument access function
    const std::string &pa_subarg_internal(const ProgArgData &pa) throw (ProgArgException);
  
    // another internal helper function
    bool pa_defined_internal(const ProgArgData &pa) throw (ProgArgException);


    class ProgArg : public ProgArgData{

      inline ProgArg(const std::string &id, unsigned int subargidx):
        ProgArgData(id,subargidx){
      }
      
      inline ProgArg(unsigned int idx, bool danglingOnly):
        ProgArgData(idx,danglingOnly){
      }
  
      public:
      // undocumented friend
      friend const ProgArg pa(const std::string &,unsigned int) throw (ProgArgException);
      // undocumented friend
      friend const ProgArg pa(unsigned int,bool);
      // yet another one
      friend bool pa_defined_internal(const ProgArgData &pa) throw (ProgArgException);


      int n() const throw (ProgArgException);

      Any operator[](int subArgIdx) const throw (ProgArgException);
  

      template<class T>
      inline operator T() const throw (ProgArgException){
        return parse<T>(pa_subarg_internal(*this));
      }
  
      template<class T>
      inline T as() const throw (ProgArgException){
        return parse<T>(pa_subarg_internal(*this));
      }
      

      inline std::string operator*() const throw (ProgArgException){
        return pa_subarg_internal(*this);
      }
      
      inline const std::string &getID() const {
        return id;
      }
    };
  
    inline std::ostream &operator<<(std::ostream &s,const ProgArg &pa){
      return s << pa.as<std::string>();
    }
    
    // explicit specialization for bool types (returns whether the arg was actually given)
    template<>
    inline ProgArg::operator bool() const throw(utils::ProgArgException){
      return pa_defined_internal(*this);
    }
  
    // explicit specialization for bool types (returns whether the arg was actually given)
    template<>
    inline bool ProgArg::as() const throw (ProgArgException){
      return pa_defined_internal(*this);
    }
  


    inline bool operator&&(const ProgArg &a, const ProgArg &b){
      return a.as<bool>() && b.as<bool>();
    }
  

    inline bool operator&&(const ProgArg &a, bool b){ 
      return b && a.as<bool>();
    }
  

    inline bool operator&&(bool &b, const ProgArg &a){ 
      return b && a.as<bool>();
    }
  

    inline bool operator||(const ProgArg &a, const ProgArg &b){
      return a.as<bool>() || b.as<bool>();
    }

    inline bool operator||(const ProgArg &a, bool b){ 
      return b || a.as<bool>();
    }
  

    inline bool operator||(bool &b, const ProgArg &a){ 
      return b || a.as<bool>();
    }
  
  
  
  

    inline const ProgArg pa(const std::string &id, unsigned int subargidx=0) throw (ProgArgException){
      if(!id.length()) THROW_ProgArgException("invalid programm argument id ''");
      return ProgArg(id,subargidx);
    }
    

    inline const ProgArg pa(unsigned int idx, bool danglingOnly=true){
      return ProgArg(idx,danglingOnly);
    }
    
    
    template<class T>
    inline const T pa_def(const std::string &id, unsigned int subargidx, const T &def) throw (ProgArgException){
      const ProgArg p = pa(id,subargidx);
      return p ? parse<T>(p) : def;
    }
  
    template<class T>
    inline const T pa_def(const std::string &id, const T &def) throw (ProgArgException){
      return pa_def(id,0,def);
    }
  
  
    

    unsigned int pa_get_count(bool danglingOnly=true);
  

    const std::string &pa_get_progname(bool fullpath=false);
  
    void pa_show_usage(const std::string &msg="");
    
    // utility class which allows the user to call the paex-function in a 'stacked' manner
    struct PAEX{
      PAEX operator()(const std::string &pa, const std::string &ex);
    };


    inline PAEX pa_explain(const std::string &pa, const std::string &ex){
      pa_explain_internal(pa,ex);
      return PAEX();
    }
  
    // deferred implementation of stacking operator
    inline PAEX PAEX::operator()(const std::string &pa, const std::string &ex){
      return pa_explain(pa,ex);
    }


    void pa_init(int n,char **ppc,const std::string &init, bool allowDanglingArgs=false);
  
  
    void pa_show();
  

    void pa_set_license(const std::string &newLicenseText);
    

    void pa_set_help_text(const std::string &newHelpText);
    
    std::string pa_get_license();
    
    std::string pa_get_help_text();
  } // namespace utils
}