gitarg.hh

Go to the documentation of this file.

#ifndef DRAMA2_GITARG_INC
#define DRAMA2_GITARG_INC
/*
 * History:
     04-Jul-2014 - TJF - Original version
     23-Mar-2018 - TJF - Ensure that in any case where we are throwing but might
                           have ERS reports, that we create the exception the
                           long way and add any ERS reports to the exception.
 
 * The above ID is for Doxygen, this one has the format ACMM is looking for.
 * "@(#) $Id$"
 */
 
#include "drama.hh"
#include "drama/thread.hh"
#include "drama/fmt/format.h"
#include "Git.h"
#include <string>
#include <limits.h>
#include <type_traits>
namespace drama {
    namespace gitarg {
 
         enum class Flags {
                NoFlagSet=0,               
                Upper=GIT_M_ARG_UPPER,    
                Lower=GIT_M_ARG_LOWER,    
                KeepErr=GIT_M_ARG_KEEPERR,
                Abbrev = GIT_M_ARG_ABBREV,
                LastBit=GIT_M_ARG_LASTBIT, 
                KeepValErr=GIT_M_ARG_KEEPVALERR
        };
        constexpr Flags operator|(Flags f1, Flags f2) { 
            return Flags(unsigned(f1)|unsigned(f2)); 
        }
        inline bool IsFlagSet(const Flags f1, const Flags f2) { 
            if ((unsigned int)(f1) & (unsigned int)(f2))
                return true;
            else
                return false;
        }
 
        /*
         * This method invokes the drama::Task static equivalent, but
         * catches the exception and provides a more precise message.
         */
        inline void ___CheckLockTaken(
            const std::string & func,
            const std::string & file,
            const int lineNum)  {
 
            try 
            {
                drama::Task::CheckLockTaken(__func__, __FILE__, __LINE__);
            }
            catch (const drama::Exception &e)
            {
                if (e.dramaStatus() == DRAMA2__LOCK_ERR) 
                {
                    throw drama::Exception(func, file, lineNum,
                                           "Programming error - the program invoked a gitarg::Get() method (or constructor) without having taken the DRAMA lock.  Please copy stack trace above to support.",
                                           DRAMA2__LOCK_ERR, true); 
                }
                throw;
                       
            }
  
        }
        /* Method for internal use only, used to add Enum value possibilities to 
         * an exception.
         * 
         * @param flags    Which GIT Flags apply. Interested in if "Upper",
         *                  "Lower" and/or "Abbrev" are set.
         * @param strings A pointer to a array of pointer to char, which
         *                is a character array to be passed to 
         *                DCF(GitArgGetS).   This array contains the 
         *                list of strings to be accepted with a 
         *                terminating null. 
         * @param except  The exception to add the enum values too.
         */
        extern void __AddEnumPossiblities(const Flags flags,
                                          const char  **strings, 
                                          drama::Exception *except);
        class EnumLookupClass {
        public:
            virtual unsigned int GetMaxValue() const = 0;
            virtual const char  ** GetStringArray() const = 0;
            virtual ~EnumLookupClass() {}
        };
 
        template <typename LookupClass, typename EnumType> class Enum  {
        private:
            EnumType _value;            // The underlying value and the only memory used by the class.
            LookupClass lookupObject; // allows us to invoke the methods of this class.
 
            /*
             * Set the value of the object from an int.  If out of range, 
             * set to GetMaxValue + 1 (the invalid value).
             */
            void SetValue(const unsigned int i) {
                if (i > lookupObject.GetMaxValue()) 
                    _value = InvalidValue();
                else
                    _value = (EnumType)i;           
            }
            /*
             * Simply return the invalid value converted to int.
             */
            EnumType InvalidValue() const {
                return (EnumType)(lookupObject.GetMaxValue()+1);
            }
        protected:
        public:
            Enum() {
                _value = InvalidValue();
            }
            Enum(EnumType InitialValue) : _value(InitialValue) {}
 
            D2DEPRECATED_EXPLAIN("Replace by overload with enum default instead of string default") 
            Enum(const sds::Id& Id,
                 const std::string & Name,
                 const int Position,
                 const std::string & Default,
                 const Flags flags = Flags::Upper|Flags::Abbrev|Flags::KeepErr) 
                :_value(InvalidValue()) {
                Get(Id, Name, Position, Default, flags);
            }
 
            Enum(const sds::Id& Id,
                 const std::string & Name="Argument1",
                 const int Position=1,
                 const EnumType Default = static_cast<EnumType>(0),
                 const Flags flags = Flags::Upper|Flags::Abbrev|Flags::KeepErr) 
                :_value(InvalidValue()) {
                Get(Id, Name, Position, Default, flags);
            }
 
 
            D2DEPRECATED_EXPLAIN("Replace by overload with enum default instead of string default") 
            Enum(
                drama::thread::TAction *taction,
                const sds::Id& Id,
                const std::string & Name,
                const int Position,
                const std::string & Default,
                const Flags flags = Flags::Upper|Flags::Abbrev|Flags::KeepErr) 
                :_value(InvalidValue()) {
 
                drama::thread::AccessDrama dramaLock(*taction);
                Get(Id, Name, Position, Default, flags);
            }
 
 
            Enum(
                drama::thread::TAction *taction,
                const sds::Id& Id,
                const std::string & Name="Argument1",
                const int Position=1,
                const EnumType Default = static_cast<EnumType>(0),
                const Flags flags = Flags::Upper|Flags::Abbrev|Flags::KeepErr) 
                :_value(InvalidValue()) {
 
                drama::thread::AccessDrama dramaLock(*taction);
                Get(Id, Name, Position, Default, flags);
            }
 
            D2DEPRECATED_EXPLAIN("Replace by overload with enum default instead of string default") 
            void Get(const sds::Id& Id,
                     const std::string & Name,
                     const int Position,
                     const std::string & Default,
                     const Flags flags = Flags::Upper|Flags::Abbrev|Flags::KeepErr)    {
 
                EnumType enumDefault = static_cast<EnumType>(0);
                if (Default != "")
                {
                    DramaTHROW(DRAMA2__GITARG_ENUM_INVDEF, 
                                "drama::gitarg::Enum type - use of Default string invalid, change to non-deprecated Get()/Constructor.");                    
                }
                Get(Id, Name, Position, enumDefault, flags);
            }
                      
            void Get(const sds::Id& Id,
                     const std::string & Name="Argument1",
                     const int Position=1,
                     const EnumType Default = static_cast<EnumType>(0),
                     const Flags flags = Flags::Upper|Flags::Abbrev|Flags::KeepErr)    {
 
                // We must have the DRAMA lock - otherwise ERS causes problems.
                gitarg::___CheckLockTaken(__func__, __FILE__, __LINE__);
 
                char string[100];
                int index;
                StatusType status = STATUS__OK;
                GitArgGetS((SdsIdType)Id,Name.c_str(),Position,
                           lookupObject.GetStringArray(), "" /* default value must be empty string */,
                           (int)(flags),sizeof(string),string,&index,&status);
                
                if (status  != STATUS__OK)
                {
                    drama::Exception except(__func__, __FILE__, __LINE__, 
                                            "Failed to fetch Enumerated Argument from SDS", 
                                            status);
                    //__AddEnumPossiblities(flags, lookupObject.GetStringArray(), status);
                    except.AddErs();  
                    __AddEnumPossiblities(flags, lookupObject.GetStringArray(), &except);
                    throw except;
                }
                /* index == -1 means we take the default */
                if (index == -1)
                    index = static_cast<int>(Default);
 
                SetValue(static_cast<unsigned>(index));
             };
            operator EnumType() const {
                return _value;
            }
            operator std::string() const {
                if (_value == InvalidValue())
                    DramaTHROW(DRAMA2__GITARG_ENUM_INVVAL, 
                        "drama::gitarg::Enum value is invalid - was not initialised to a valid enum value.");
                return lookupObject.GetStringArray()[int(_value)];
            }
            Enum& operator=(const EnumType &rhs) {
                _value = rhs;
                return *this;
            }
 
            virtual ~Enum() {};
 
        }; // Class Enum;
 
        template <typename LookupClass, typename EnumType>
        auto format_as(const gitarg::Enum<LookupClass, EnumType> &e) { return std::string(e); }
 
 
        template <long int MinVal,long int MaxVal, long int DefaultVal=0> class Real  {
        private:
            // Return the range we need.
            virtual const double * Range() { 
                static const double range[] = { MinVal, MaxVal };
                return range;        
            }
            double _value;
        public:
            Real(const double def = (double)DefaultVal) : _value(def) { 
            }  
            Real (      /*Constructor with automatic Get        */
                const sds::Id& Id,
                const std::string & Name="Argument1",
                const int Position=1,
                const double  Default = (double)DefaultVal,
                const Flags flags = Flags::KeepErr) : _value(Default) {
                
                Get(Id,Name,Position,Default,flags);
            }
 
            Real (      /*Constructor with automatic Get        */
                drama::thread::TAction *taction,
                const sds::Id& Id,
                const std::string & Name="Argument1",
                const int Position=1,
                const double  Default = (double)DefaultVal,
                const Flags flags = Flags::KeepErr) : _value(Default) {
                
                drama::thread::AccessDrama dramaLock(*taction);
                Get(Id,Name,Position,Default,flags);
            }
 
            Real (      /*Constructor with automatic Get        */
                const sds::Id& Id,
                const double Min,
                const double Max,
                const std::string & Name="Argument1",
                const int Position=1,
                const double  Default = (double)DefaultVal,
                const Flags flags = Flags::KeepErr) : _value(Default) {
                
                Get(Id,Min, Max, Name,Position,Default,flags);
            }
 
            Real (      /*Constructor with automatic Get        */
                drama::thread::TAction *taction,
                const sds::Id& Id,
                const double Min,
                const double Max,
                const std::string & Name="Argument1",
                const int Position=1,
                const double  Default = (double)DefaultVal,
                const Flags flags = Flags::KeepErr) : _value(Default) {
                
                drama::thread::AccessDrama dramaLock(*taction);
                Get(Id,Min, Max, Name,Position,Default,flags);
            }
 
 
            virtual ~Real() {}
 
            virtual void Get(           /* Get value from Sds structure */
                const sds::Id& Id,
                const std::string & Name="Argument1",
                const int Position=1,
                const double  Default = (double)(DefaultVal),
                const Flags flags = Flags::KeepErr) {
 
                // We must have the DRAMA lock - otherwise ERS causes problems.
                gitarg::___CheckLockTaken(__func__, __FILE__, __LINE__);
 
 
                StatusType status = STATUS__OK;
                GitArgGetD((SdsIdType)Id,Name.c_str(),
                           Position,Range(),Default,
                           (int)(flags),&_value,&status);
 
                if (status  != STATUS__OK)
                {
                    drama::Exception except(__func__, __FILE__, __LINE__, 
                                            "Failed to fetch real number Argument from SDS",
                                            status);
 
                    except.AddErs();  
                    throw except;
                }
            }
 
            virtual void Get(           /* Get value from Sds structure */
                const sds::Id& Id,
                const double Min,
                const double Max,
                const std::string & Name="Argument1",
                const int Position=1,
                const double  Default = (double)(DefaultVal),
                const Flags flags = Flags::KeepErr) {
 
                // We must have the DRAMA lock - otherwise ERS causes problems.
                gitarg::___CheckLockTaken(__func__, __FILE__, __LINE__);
 
 
                const double range[] = { Min, Max };
 
                StatusType status = STATUS__OK;
                GitArgGetD((SdsIdType)Id,Name.c_str(),
                           Position, range,Default,
                           (int)(flags),&_value,&status);
 
                if (status  != STATUS__OK)
                {
                    drama::Exception except(__func__, __FILE__, __LINE__, 
                                            "Failed to fetch real number Argument from SDS",
                                            status);
 
                    except.AddErs();  
                    throw except;
                }
            }
 
            operator double() const {
                return (_value);
            }
        }; // Class Real.
 
        template <long int MinVal=LONG_MIN, 
                  long int MaxVal=LONG_MAX, 
                  long int DefaultVal=0>
        auto format_as(Real<MinVal, MaxVal, DefaultVal> r) { return static_cast<double>(r); }
 
 
        template <long int MinVal=LONG_MIN, 
                  long int MaxVal=LONG_MAX, 
                  long int DefaultVal=0> class Int {
        private:
            // Return the range we need.
            virtual const long int * Range() { 
                static const long int range[] = { MinVal, MaxVal };
                return range;        
            }
            long _value;
        public:
            Int(const long def = DefaultVal) :  _value(def) { }
 
            Int (       /*Constructor with automatic Get        */
                const sds::Id& Id,
                const std::string & Name = "Argument1",
                const int Position=1,
                const long  Default = DefaultVal,
                const Flags flags = Flags::KeepErr) : _value(Default) {
 
                Get(Id,Name,Position,Default,flags);
            }
 
            Int (       /*Constructor with automatic Get        */
                drama::thread::TAction *taction,
                const sds::Id& Id,
                const std::string & Name = "Argument1",
                const int Position=1,
                const long  Default = DefaultVal,
                const Flags flags = Flags::KeepErr) : _value(Default) {
 
                drama::thread::AccessDrama dramaLock(*taction);
                Get(Id,Name,Position,Default,flags);
            }
 
            Int (       /*Constructor with automatic Get        */
                const sds::Id& Id,
                const long Min,
                const long Max,
                const std::string & Name = "Argument1",
                const int Position=1,
                const long  Default = DefaultVal,
                const Flags flags = Flags::KeepErr) : _value(Default) {
 
                Get(Id,Min, Max, Name,Position,Default,flags);
            }
 
            Int (       /*Constructor with automatic Get        */
                drama::thread::TAction *taction,
                const sds::Id& Id,
                const long Min,
                const long Max,
                const std::string & Name = "Argument1",
                const int Position=1,
                const long  Default = DefaultVal,
                const Flags flags = Flags::KeepErr) : _value(Default) {
 
                drama::thread::AccessDrama dramaLock(*taction);
                Get(Id,Min, Max, Name,Position,Default,flags);
            }
 
 
 
            virtual ~Int() {}
            virtual void Get(           /* Get value from Sds structure */
                const sds::Id& Id,
                const std::string & Name="Argument1",
                const int Position=1,
                const long int Default = DefaultVal,
                const Flags flags = Flags::KeepErr) {
 
                // We must have the DRAMA lock - otherwise ERS causes problems.
                gitarg::___CheckLockTaken(__func__, __FILE__, __LINE__);
 
 
                StatusType status = STATUS__OK;
                GitArgGetI((SdsIdType)Id,Name.c_str(),Position,Range(),Default,
                           (int)(flags),&_value,&status);
 
                if (status  != STATUS__OK)
                {
                    drama::Exception except(__func__, __FILE__, __LINE__, 
                                            "Failed to fetch integer Argument from SDS",
                                            status);
                    
                    except.AddErs();  
                    throw except;
                }
 
            }
 
            virtual void Get(           /* Get value from Sds structure */
                const sds::Id& Id,
                const long Min,
                const long Max,
                const std::string & Name="Argument1",
                const int Position=1,
                const long int Default = DefaultVal,
                const Flags flags = Flags::KeepErr) {
 
                // We must have the DRAMA lock - otherwise ERS causes problems.
                gitarg::___CheckLockTaken(__func__, __FILE__, __LINE__);
 
                const long range[] = { Min, Max };
 
 
                StatusType status = STATUS__OK;
                GitArgGetI((SdsIdType)Id,Name.c_str(),Position,range,Default,
                           (int)(flags),&_value,&status);
 
                if (status  != STATUS__OK)
                {
                    drama::Exception except(__func__, __FILE__, __LINE__, 
                                            "Failed to fetch integer Argument from SDS",
                                            status);
                    
                    except.AddErs();  
                    throw except;
                }
 
            }
 
            operator long int() const {
                return (_value);
            }
        
 
        }; // class Int.
 
        template <long int MinVal=LONG_MIN, 
                  long int MaxVal=LONG_MAX, 
                  long int DefaultVal=0>
        auto format_as(Int<MinVal, MaxVal, DefaultVal> i) { return long(i); }
 
        class String : public std::string {
            using std::string::string; // Inherit constructors.
        private:
            // Enough space for conversion of doubles/long ints.
            static const unsigned _DefaultStringLength = 100;
 
            void RawGet (const sds::Id& Id, const std::string &Name,
                         int Position, const std::string &Default,
                         Flags flags, StatusType * status);
 
        public:
            String( const sds::Id& Id,
                    const std::string &Name = "Argument1",
                    const int Position = 1,
                    const std::string &Default = "",
                    const Flags flags = Flags::KeepErr) {
                this->Get(Id, Name, Position, Default, flags);
            }
 
            String(   
                drama::thread::TAction *taction,
                const sds::Id& Id,
                const std::string &Name = "Argument1",
                const int Position = 1,
                const std::string &Default = "",
                const Flags flags = Flags::KeepErr) {
                
                drama::thread::AccessDrama dramaLock(*taction);
                this->Get(Id, Name, Position, Default, flags);
            }
            String(const String&) = default;
 
            String(String&&) = default;
            /*
             * From:
             *  http://codexpert.ro/blog/2013/08/26/inherited-constructors-in-cpp11/
             * If in the derived class you add a new specific constructor 
             * after you use the using directive, you lost the possibility 
             * of using the default constructor (even though it is in the 
             * base class). So, if it is needed a specific constructor, you 
             * need to add a default one, even one using that no-parameter 
             * base constructor:
             */
            String() {
            }
            /*
             * Implementation of this method is in gitarg.cpp.
             */
            virtual void Get (const sds::Id& Id,
                              const std::string &Name = "Argument1",
                              const int Position = 1,
                              const std::string &Default = "",
                              const Flags flags = Flags::KeepErr);
 
            String operator=(const std::string &str) {
                this->std::string::operator=(str);
                return *this;
            }
            String operator=(const String &str) {
                this->std::string::operator=(str);
                return *this;
            }
            String operator=(const char *s) {
                this->std::string::operator=(s);
                return *this;
            }
            String& operator=(char c) {
                this->std::string::operator=(c);
                return *this;
            }
 
 
        }; /* String */
 
        inline auto format_as(const String &s) { return std::string(s); }
 
 
        class Bool  {
        private:
            bool _value;
            static const GitLogStrType lookupTable[];
        protected:
            virtual const GitLogStrType * Lookup() {
                return lookupTable;
            }
        public:
            Bool(bool initVal=false) : _value(initVal) { }
 
            Bool (      /*Constructor with automatic Get        */
                const sds::Id& Id,
                const std::string &Name="Argument1",
                const int Position=1,
                const bool  Default = false,
                const Flags flags = (Flags::Upper|Flags::Abbrev|Flags::KeepErr)) : _value(false)
                {
                    Get(Id,Name,Position,Default,flags);
                }
 
            Bool (      /*Constructor with automatic Get        */
                drama::thread::TAction *taction,
                const sds::Id& Id,
                const std::string &Name="Argument1",
                const int Position=1,
                const bool  Default = false,
                const Flags flags = (Flags::Upper|Flags::Abbrev|Flags::KeepErr)) : _value(false)
                {
                    drama::thread::AccessDrama dramaLock(*taction);
                    Get(Id,Name,Position,Default,flags);
                }
 
            virtual ~Bool() {}; /* Destructor for inheritors */
            virtual void Get(           /* Get value from Sds structure */
                const sds::Id& Id,
                const std::string &Name="Argument1",
                const int Position=1,
                const bool  Default = false,
                const Flags flags = (Flags::Upper|Flags::Abbrev|Flags::KeepErr)) {
 
                // We must have the DRAMA lock - otherwise ERS causes problems.
                gitarg::___CheckLockTaken(__func__, __FILE__, __LINE__);
 
 
                long int actValue = 0;
                StatusType status = STATUS__OK;
                GitArgGetL((SdsIdType)Id,Name.c_str(),Position,Lookup(),Default,
                           (int)(flags),&actValue,&status);
 
                if (status  != STATUS__OK)
                {
                    drama::Exception except(__func__, __FILE__, __LINE__, 
                                            "Failed to fetch boolean Argument from SDS", 
                                            status);
                    except.AddErs();  
                    throw except;
               }
 
                _value = actValue ? true : false;               
            };
            operator bool() const {
                return _value;
            };
            Bool operator=(const bool src) {
                _value = src;
                return *this;
            }
 
                        
        }; // class Bool
        inline auto format_as(gitarg::Bool b) { return bool(b); }
 
 
 
        class Id : public sds::Id {
        private:
            bool _readFromFile = false; // Was this read from a file.
            bool _defaultUsed = false;  // Was this read from the default.
            std::string _actualName;    // Actual name of file or structure.
 
            void UseDefaultIfReq(const std::string &name,
                                 int position,
                                 const std::string &fileName,
                                 Flags flags,
                                 StatusType status,
                                 const std::string &mess);
 
        public:
            Id() : sds::Id() { }
 
            
            Id( 
                const sds::Id& Id,
                const std::string &Name="Argument1",
                const int Position=1,
                const std::string Default = "",
                const Flags flags = Flags::KeepErr)
                {
                    Get(Id,Name,Position,Default,flags);
                }
 
 
            
            Id( 
                drama::thread::TAction *taction,
                const sds::Id& Id,
                const std::string &Name="Argument1",
                const int Position=1,
                const std::string Default = "",
                const Flags flags = Flags::KeepErr)
                {
                    drama::thread::AccessDrama dramaLock(*taction);
                    Get(Id,Name,Position,Default,flags);
                }
 
            virtual ~Id();
 
            virtual void Get(           /* Get value from Sds structure */
                const sds::Id& Id,
                const std::string &Name="Argument1",
                const int Position=1,
                const std::string Default = "",
                const Flags flags = (Flags::KeepErr));
 
 
            virtual std::string ActualName() const;
            virtual bool WasReadFromFile() const;
 
            virtual bool WasReadFromDefault() const;
                
 
        }; // class Id
 
 
        class Filename : public String {
            //String::String; // Inherit constructors.
        public:
            Filename( const sds::Id& Id,
                    const std::string &Name = "Argument1",
                    const int Position = 1,
                    const std::string &Default = "",
                      const Flags flags = Flags::KeepErr) {
                this->Get(Id, Name, Position, Default, flags);
            }
 
            Filename( 
                drama::thread::TAction *taction,
                const sds::Id& Id,
                const std::string &Name = "Argument1",
                const int Position = 1,
                const std::string &Default = "",
                const Flags flags = Flags::KeepErr) {
 
 
                drama::thread::AccessDrama dramaLock(*taction);
                this->Get(Id, Name, Position, Default, flags);
            }
 
 
            /*
             * From:
             *  http://codexpert.ro/blog/2013/08/26/inherited-constructors-in-cpp11/
             * If in the derived class you add a new specific constructor 
             * after you use the using directive, you lost the possibility 
             * of using the default constructor (even though it is in the 
             * base class). So, if it is needed a specific constructor, you 
             * need to add a default one, even one using that no-parameter 
             * base constructor:
             */
            Filename() {
            }
 
 
            virtual void Get (const sds::Id& Id,
                              const std::string &Name = "Argument1",
                              const int Position = 1,
                              const std::string &Default = "",
                              const Flags flags = Flags::KeepErr);
 
 
        }; // class Filename
        
        inline auto format_as(const Filename &f) { return std::string(f); }
 
 
        struct ArgFlagVal {
            std::string name;
            unsigned flag;
        };
        using ArgFlagValVector =  std::vector<ArgFlagVal>;
 
 
 
        /*
         * Internal method only.
         *
         * Used by ArgFlags::Get() to get a given argument as a string, converting
         * it to upper case if requested.
         * 
         * Returns the value of the string (converted to upper case if
         * requested) or an empty string if the value does not exist. Does
         * not throw an exception if the value does not exist.
         *
         * @param Id        The SDS structure to read the flags from
         * @param pos       Position of the argument to read.
         * @param toUpper   Do we convert the result to upper case. If
         *                     false, leave as found.
         *
         * @return The value found.  If no value was found, return an empty
         *                  string (does not throw for no value found!)
         */
        extern std::string _GetString(const sds::Id& Id, unsigned pos, bool toUpper);
 
        template<class ContainerType,
             /*
              * This complicated bit of code is about ensuring that only containers containing
              * a sub-class of "ArgFlagVal" are considered when trying to determine if
              * this template function is a valid specialization to use.
              *
              * A relevant reference is SFINAE ("Substitution Failure Is Not An Error")
              *  E.g. http://en.cppreference.com/w/cpp/language/sfinae
              *
              * The problem we are tying to solve is that without this, any type
              * could trigger this specialization.   Compilation
              * would then fail late with a poor error message.
              *
              * std::enable_if is being used to this template is only used when the
              * ContainerType value is a sub-class of ArgFlagVal.  The following
              * references will help explain this:
              *   http://www.cplusplus.com/reference/type_traits/enable_if/?kw=enable_if
              *   http://www.boost.org/doc/libs/1_45_0/libs/utility/enable_if.html
              *
              * In addition, the use of "typename ContainerType::value_type" is to ensure
              * we refer to the actual type of the ContainerType template argument.
              * This should also trigger a failure if the container does not have a
              * value_type member.  Here  typename can be used to declare that a
              * dependent name is a type.
              */
                 typename std::enable_if<std::is_base_of<ArgFlagVal,
                                                         typename ContainerType::value_type>::value>::type* = nullptr>
 
 
        class ArgFlags {
            const ContainerType _validFlags;    // Container with set of valid flags
            const bool          _ignoreCase;    // Do we ignore case?
            unsigned _theValue = 0;             // The mask of flag values.
            
        public:
            ArgFlags(const ContainerType &validFlagVals, bool ignoreCase=true) :
                _validFlags(validFlagVals), _ignoreCase(ignoreCase) {
            }
            ArgFlags(const ContainerType &validFlagVals,
                     const sds::Id& Id,
                     const unsigned First = 1,
                     const unsigned Last = 0,
                     const bool     FailOnInvalid = true,
                     const bool     IgnoreCase=true) :
                _validFlags(validFlagVals), _ignoreCase(IgnoreCase) {
                Get(Id, First, Last, FailOnInvalid);
            }           
            unsigned Get(const sds::Id& Id,
                         const unsigned First = 1,
                               unsigned Last = 0,
                         const bool     FailOnInvalid = true) {
 
                _theValue = 0;  // Clear the value on entry.
             
                if (Last == 0) Last = UINT_MAX;
 
                /*
                 * Validate arguments.
                 */
                if (First < 1) 
                {
                    DramaTHROW_F(DRAMA2__GITARG_INVPOS,
                                 "ArgFlags First argument position value of {0} is less then min of 1",
                                 First);
                }
                if (Last < First)
                {
                    DramaTHROW_F(DRAMA2__GITARG_INVPOS,
                                 "ArgFlags Last argument position value of {0} is less then First of {1}",
                                 Last, First);
 
                }
                /*
                 * If no argument was supplied, then just return 0.
                 */
                if (!Id) return 0;
                /*
                 * Work through arguments.
                 */
                for (unsigned arg = First; arg < Last ; arg++) 
                {
                    /*
                     * Use this static method to get the actual string
                     * value - not dependent on the template so
                     * more efficient compilation.
                     */
                    auto thisVal = _GetString(Id, arg, _ignoreCase);
 
                    /*
                     * If this is a null value, we are done.
                     */
                    if (thisVal == "") 
                        return _theValue;
 
                    /*
                     * Work through the possible values.  If we find
                     * it, add the relevant flag value to the set of
                     * values.
                     */
                    bool found = false;
                    for (auto & flag : _validFlags)
                    {
                        if (flag.name == thisVal)
                        {
                            _theValue |= flag.flag;
                            found = true;
                            break;
                        }
                    }
                    if ((!found)&&(FailOnInvalid))
                    {
                        drama::Exception except(__func__, __FILE__, __LINE__,  
                                                "", DRAMA2__GITARG_INVALID_FLAGVAL);
 
                        except.FmtWriteF("Argument value at position {0}, \"{1}\", is not an acceptable flag value", 
                                        arg, thisVal);
                        except.AddErs();  
                        AddFlagPossiblities(&except);
                        throw except;
                    }
 
                }
                
                return _theValue;
                
            }
            unsigned GetVal() const {
                return _theValue;
            }
            bool IsSet(unsigned flags) const {
                return ((_theValue & flags) == flags);
            }
        private:
            /* Add Flat value possibilities to an exception.
             * 
             * @param except  The exception to add the enum values too.
             */
            void AddFlagPossiblities(drama::Exception *except) {
                // We must have the DRAMA lock - otherwise ERS causes problems.
                gitarg::___CheckLockTaken(__func__, __FILE__, __LINE__);
                std::ostringstream s;
 
                (*except) << "\n Accepted flags are:\n";
                s << "    ";
                for (auto & flag : _validFlags)
                {
                    s << flag.name << ", ";
                }
                auto str = s.str();
                // Remove the trailing ", "
                str.pop_back();
                str.pop_back();
                (*except) << str << '\n';
 
                if (_ignoreCase)
                {
                    (*except) << "  Case is ignored.";
                }
            }
 
        }; // class ArgFlags
 
 
 
    } // namespace gitarg
    
} // namespace drama
 
#endif  /* define DRAMA2_GITARG_INC */