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.LGPL **
** 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/CompatMacros.h>
#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 ICLUtils_API const std::string &pa_subarg_internal(const ProgArgData &pa);
      friend ICLUtils_API bool pa_defined_internal(const ProgArgData &pa);
      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
    ICLUtils_API void pa_explain_internal(const std::string &pa, const std::string &ex);

    // internal sub-argument access function
    ICLUtils_API const std::string &pa_subarg_internal(const ProgArgData &pa);

    // another internal helper function
    ICLUtils_API bool pa_defined_internal(const ProgArgData &pa);

    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 ICLUtils_API const ProgArg pa(const std::string &,unsigned int);
      // undocumented friend
      friend ICLUtils_API const ProgArg pa(unsigned int, bool);
      // yet another one
      friend ICLUtils_API bool pa_defined_internal(const ProgArgData &pa);

      ICLUtils_API int n() const;

      ICLUtils_API Any operator[](int subArgIdx) const;


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

      inline bool operator!() const{
        return !pa_defined_internal(*this);
      }

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


      inline std::string operator*() const{
        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 {
      return pa_defined_internal(*this);
    }

    // explicit specialization for bool types (returns whether the arg was actually given)
    template<>
    inline bool ProgArg::as() const{
      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){
      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){
      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){
      return pa_def(id,0,def);
    }




    ICLUtils_API unsigned int pa_get_count(bool danglingOnly = true);


    ICLUtils_API const std::string &pa_get_progname(bool fullpath = false);

    ICLUtils_API void pa_show_usage(const std::string &msg = "");

    // utility class which allows the user to call the paex-function in a 'stacked' manner
    struct ICLUtils_API 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);
    }

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


    ICLUtils_API void pa_show();


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


    ICLUtils_API void pa_set_help_text(const std::string &newHelpText);

    ICLUtils_API std::string pa_get_license();

    ICLUtils_API std::string pa_get_help_text();
  } // namespace utils
}