nopt.hpp

// LICENSE: (Please see the file COPYING for details)
//
// NUS - Nemesis Utilities System: A C++ application development framework 
// Copyright (C) 2006, 2008 Otavio Rodolfo Piske
//
//  This file is part of NUS
//
//  This library is free software; you can redistribute it and/or
//  modify it under the terms of the GNU Lesser General Public
//  License as published by the Free Software Foundation version 2.1
//  of the License.
//
//  This library is distributed in the hope that it will be useful,
//  but WITHOUT ANY WARRANTY; without even the implied warranty of
//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
//  Lesser General Public License for more details.
//
//  You should have received a copy of the GNU Lesser General Public
//  License along with this library; if not, write to the Free Software
//  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
//
#ifndef NOPT_HPP
#define NOPT_HPP

#include "noutput.h"

template <typename HandlerType>
class NOpt: public NObject {
      public:
            typedef bool (HandlerType::*Handler)(const NOpt &);
      
            NOpt(void);
            
            
            NOpt(const NString &opt_short, const NString &opt_long, bool opt_opt, 
                  const NString &help, Handler handler);
            
            ~NOpt();
            
            void setShort(const NString &opt_short);
            
            NString getShort(void) const;
            
            void setLong(const NString &opt_long);
            
            NString getLong(void) const;
            
            
            void setOpt(bool opt_opt);
            
            bool hasOpt(void) const;
            
            
            void setHelp(const NString &help);
            
            NString getHelp(void) const;
            
            void addValue(const NString &value);
            
            
            void addValues(const NList<NString> &values);
            
            
            NList<NString> getValues(void) const;
            
            // uses NOpt<HandlerType>::Handler instead of Handler to avoid 
            // warnings when generating the documentation
            void setHandler(NOpt<HandlerType>::Handler handle);
            
            Handler getHandler(void) const;
            
            bool isNull(void) const;
            
            
            void setRequired(bool required);
            
            
            bool getRequired(void) const;
      
            bool operator==(const NOpt &rhs) const;
            
            
            bool operator!=(const NOpt &rhs) const;
      private:
            NString m_short;
            NString m_long;
            bool m_opt;
            NString m_help;
            NList<NString> m_values;
            Handler m_handler;

            NException maxCountExceeded(void) const;
};


template <typename HandlerType>
NOpt<HandlerType>::NOpt(void)
            : NObject(),
            m_short(),
            m_long(),
            m_opt(),
            m_help(),
            m_values(),
            m_handler(NULL)
{

}


template <typename HandlerType>
NOpt<HandlerType>::NOpt(const NString &opt_short, const NString &opt_long, 
                        bool opt_opt, const NString &help, Handler handler)
                  : NObject(), 
                  m_short(opt_short), 
                  m_long(opt_long),
                  m_opt(opt_opt),
                  m_help(help),
                  m_values(),
                  m_handler(handler)
{

}


template <typename HandlerType>
NOpt<HandlerType>::~NOpt() {

}


template <typename HandlerType>
void NOpt<HandlerType>::setShort(const NString &opt_short) {
      m_short = opt_short;
}


template <typename HandlerType>
NString NOpt<HandlerType>::getShort(void) const {
      return m_short;
}


template <typename HandlerType>
void NOpt<HandlerType>::setLong(const NString &opt_long) {
      m_long = opt_long;
}


template <typename HandlerType>
NString NOpt<HandlerType>::getLong(void) const {
      return m_long;
}


template <typename HandlerType>
void NOpt<HandlerType>::setOpt(bool opt_opt) {
      m_opt = opt_opt;
}


template <typename HandlerType>
bool NOpt<HandlerType>::hasOpt(void) const {
      return m_opt;
}


template <typename HandlerType>
void NOpt<HandlerType>::setHelp(const NString &help) {
      m_help = help;
}


template <typename HandlerType>
NString NOpt<HandlerType>::getHelp(void) const {
      return m_help;
}



template <typename HandlerType>
void NOpt<HandlerType>::addValue(const NString &value) {
      m_values.append(value); 
}


template <typename HandlerType>
void NOpt<HandlerType>::addValues(const NList<NString> &values) {
      m_values.copy(values);
}


template <typename HandlerType>
NList<NString> NOpt<HandlerType>::getValues(void) const {
      return m_values;
}


template <typename HandlerType>
void NOpt<HandlerType>::setHandler(typename NOpt<HandlerType>::Handler handler) {
      m_handler = handler;
}


template <typename HandlerType>
typename NOpt<HandlerType>::Handler NOpt<HandlerType>::getHandler(void) const {
      return m_handler;
}


template <typename HandlerType>
bool NOpt<HandlerType>::isNull(void) const {
      if ((m_short == 0) && (m_long == "")) {
            return true;
      }
      
      return false;
}


template <typename HandlerType>
bool NOpt<HandlerType>::operator==(const NOpt &rhs) const {
      if (m_short == "") { 
            if (m_long == rhs.getLong()) {
                  return true;
            }
            
            return false;
      }

      if (m_short == rhs.getShort()) {
            return true;
      }
      
      if (m_long == rhs.getLong()) {
            return true;
      }
      

      return false; 
}


template <typename HandlerType>
bool NOpt<HandlerType>::operator!=(const NOpt &rhs) const {
      if (m_short == "") { 
            if (m_long != rhs.getLong()) {
                  return true;
            }

            return false;
      }


      if (m_short != rhs.getShort()) {
            if (m_long != rhs.getLong()) {
                  return true;
            }
      }

      return false; 
}

#endif // NOPT_HPP

---