cmdline_option.h

Go to the documentation of this file.

/* Copyright (c) 2008-2022 the MRtrix3 contributors.
 *
 * This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/.
 *
 * Covered Software is provided under this License on an "as is"
 * basis, without warranty of any kind, either expressed, implied, or
 * statutory, including, without limitation, warranties that the
 * Covered Software is free of defects, merchantable, fit for a
 * particular purpose or non-infringing.
 * See the Mozilla Public License v. 2.0 for more details.
 *
 * For more details, see http://www.mrtrix.org/.
 */
 
#ifndef __cmdline_option_h__
#define __cmdline_option_h__
 
#include <cassert>
#include <limits>
#include <string>
 
#ifdef None
# undef None
#endif
 
#include "mrtrix.h"
#include "types.h"
 
namespace MR
{
  namespace App
  {
 
    enum ArgType {
      Undefined,
      Text,
      Boolean,
      Integer,
      Float,
      ArgFileIn,
      ArgFileOut,
      ArgDirectoryIn,
      ArgDirectoryOut,
      Choice,
      ImageIn,
      ImageOut,
      IntSeq,
      FloatSeq,
      TracksIn,
      TracksOut,
      Various
    };
 
    using ArgFlags = int;
    constexpr ArgFlags None = 0;
    constexpr ArgFlags Optional = 0x1;
    constexpr ArgFlags AllowMultiple = 0x2;
 
 
 
 
    // @{
 
 
    class Argument { NOMEMALIGN
      public:
 
        Argument (const char* name = nullptr, std::string description = std::string()) :
          id (name), desc (description), type (Undefined), flags (None)
        {
          memset (&limits, 0x00, sizeof (limits));
        }
 
        const char* id;
        std::string desc;
        ArgType  type;
        ArgFlags flags;
 
        union {
          const char* const* choices;
          struct { NOMEMALIGN
            int64_t min, max;
          } i;
          struct { NOMEMALIGN
            default_type min, max;
          } f;
        } limits;
 
 
        operator bool () const {
          return id;
        }
 
 
        Argument& optional () {
          flags |= Optional;
          return *this;
        }
 
 
        Argument& allow_multiple () {
          flags |= AllowMultiple;
          return *this;
        }
 
        Argument& type_text () {
          assert (type == Undefined);
          type = Text;
          return *this;
        }
 
        Argument& type_image_in () {
          assert (type == Undefined);
          type = ImageIn;
          return *this;
        }
 
        Argument& type_image_out () {
          assert (type == Undefined);
          type = ImageOut;
          return *this;
        }
 
 
        Argument& type_integer (const int64_t min = std::numeric_limits<int64_t>::min(), const int64_t max = std::numeric_limits<int64_t>::max()) {
          assert (type == Undefined);
          type = Integer;
          limits.i.min = min;
          limits.i.max = max;
          return *this;
        }
 
 
        Argument& type_bool () {
          assert (type == Undefined);
          type = Boolean;
          return *this;
        }
 
 
        Argument& type_float (const default_type min = -std::numeric_limits<default_type>::infinity(),
                              const default_type max = std::numeric_limits<default_type>::infinity()) {
          assert (type == Undefined);
          type = Float;
          limits.f.min = min;
          limits.f.max = max;
          return *this;
        }
 
 
        Argument& type_choice (const char* const* choices) {
          assert (type == Undefined);
          type = Choice;
          limits.choices = choices;
          return *this;
        }
 
        Argument& type_file_in () {
          assert (type == Undefined);
          type = ArgFileIn;
          return *this;
        }
 
        Argument& type_file_out () {
          assert (type == Undefined);
          type = ArgFileOut;
          return *this;
        }
 
        Argument& type_directory_in () {
          assert (type == Undefined);
          type = ArgDirectoryIn;
          return *this;
        }
 
        Argument& type_directory_out () {
          assert (type == Undefined);
          type = ArgDirectoryOut;
          return *this;
        }
 
        Argument& type_sequence_int () {
          assert (type == Undefined);
          type = IntSeq;
          return *this;
        }
 
        Argument& type_sequence_float () {
          assert (type == Undefined);
          type = FloatSeq;
          return *this;
        }
 
        Argument& type_tracks_in () {
          assert (type == Undefined);
          type = TracksIn;
          return *this;
        }
 
        Argument& type_tracks_out () {
          assert (type == Undefined);
          type = TracksOut;
          return *this;
        }
 
        Argument& type_various () {
          assert (type == Undefined);
          type = Various;
          return *this;
        }
 
 
        std::string syntax (int format) const;
        std::string usage () const;
    };
 
 
 
 
 
 
 
    class Option : public vector<Argument> { NOMEMALIGN
      public:
        Option () : id (nullptr), flags (Optional) { }
 
        Option (const char* name, const std::string& description) :
          id (name), desc (description), flags (Optional) { }
 
        Option& operator+ (const Argument& arg) {
          push_back (arg);
          return *this;
        }
        operator bool () const {
          return id;
        }
 
        const char* id;
        std::string desc;
        ArgFlags flags;
 
 
        Option& required () {
          flags &= ~Optional;
          return (*this);
        }
 
 
        Option& allow_multiple () {
          flags |= AllowMultiple;
          return *this;
        }
 
        bool is (const std::string& name) const {
          return name == id;
        }
 
        std::string syntax (int format) const;
        std::string usage () const;
    };
 
 
 
 
 
 
 
    class OptionGroup : public vector<Option> { NOMEMALIGN
      public:
        OptionGroup (const char* group_name = "OPTIONS") : name (group_name) { }
        const char* name;
 
        OptionGroup& operator+ (const Option& option) {
          push_back (option);
          return *this;
        }
 
        OptionGroup& operator+ (const Argument& argument) {
          assert (!empty());
          back() + argument;
          return *this;
        }
 
        Option& back () {
          if (empty())
            push_back (Option());
          return vector<Option>::back();
        }
 
        std::string header (int format) const;
        std::string contents (int format) const;
        static std::string footer (int format);
    };
 
 
 
  }
 
}
 
#endif