Webmaster  |  Imprint 

C++ Server Pages

Main  |  License  |  Documentation  |  Download 

/home/tommi/cxxtools/include/cxxtools/arg.h

/*
 * Copyright (C) 2003,2004 Tommi Maekitalo
 * 
 * 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; either
 * version 2.1 of the License, or (at your option) any later version.
 * 
 * As a special exception, you may use this file as part of a free
 * software library without restriction. Specifically, if other files
 * instantiate templates or use macros or inline functions from this
 * file, or you compile this file and link it with other files to
 * produce an executable, this file does not by itself cause the
 * resulting executable to be covered by the GNU General Public
 * License. This exception does not however invalidate any other
 * reasons why the executable file might be covered by the GNU Library
 * General Public 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 CXXTOOLS_ARG_H
#define CXXTOOLS_ARG_H

#include <sstream>
#include <string.h>

namespace cxxtools
{


template <typename T>
class Arg
{
  public:
    Arg(const T& def = T())
      : m_value(def),
        m_isset(false)
      { }

    Arg(int& argc, char* argv[], char ch, const T& def = T())
      : m_value(def),
        m_isset(false)
    {
      set(argc, argv, ch);
    }

    Arg(int& argc, char* argv[], const char* str, const T& def = T())
      : m_value(def),
        m_isset(false)
    {
      m_isset = set(argc, argv, str);
    }

    Arg(int& argc, char* argv[])
      : m_isset(false)
    {
      m_isset = set(argc, argv);
    }

    bool set(int& argc, char* argv[], char ch)
    {
      // don't extract value, when already found
      if (m_isset)
        return false;

      for (int i = 1; i < argc - 1; ++i)
        if (argv[i][0] == '-' && argv[i][1] == ch && argv[i][2] == '\0')
        {
          std::istringstream s(argv[i + 1]);
          s >> m_value;
          if (!s.fail())
          {
            m_isset = true;
            for ( ; i < argc - 2; ++i)
              argv[i] = argv[i + 2];
            argc -= 2;
            argv[argc] = 0;
            return true;
          }
        }
      
      return false;
    }

    bool set(int& argc, char* argv[], const char* str)
    {
      // don't extract value, when already found
      if (m_isset)
        return false;

      for (int i = 1; i < argc - 1; ++i)
        if (strcmp(argv[i], str) == 0)
        {
          std::istringstream s(argv[i + 1]);
          s >> m_value;
          if (!s.fail())
          {
            m_isset = true;
            for ( ; i < argc - 2; ++i)
              argv[i] = argv[i + 2];
            argc -= 2;
            argv[argc] = 0;
            return true;
          }
        }

      return false;
    }

    bool set(int& argc, char* argv[])
    {
      // don't extract value, when already found
      if (m_isset)
        return false;

      if (argc > 1)
      {
        std::istringstream s(argv[1]);
        s >> m_value;
        if (!s.fail())
        {
          m_isset = true;
          for (int i = 1; i < argc - 1; ++i)
            argv[i] = argv[i + 1];
          argc -= 1;
          argv[argc] = 0;
        }
        else
          m_isset = false;
      }
      else
        m_isset = false;

      return m_isset;
    }

    const T& getValue() const   { return m_value; }

    operator T() const   { return m_value; }

    bool isSet() const   { return m_isset; }

  private:
    T    m_value;
    bool m_isset;
};


template <>
class Arg<bool>
{
  public:
    Arg(bool def = false)
      : m_value(def),
        m_isset(false)
        { }

    Arg(int& argc, char* argv[], char ch, bool def = false)
      : m_value(def),
        m_isset(false)
    {
      m_isset = set(argc, argv, ch);
    }

    Arg(int& argc, char* argv[], const char* str, bool def = false)
      : m_value(def),
        m_isset(false)
    {
      m_isset = set(argc, argv, str);
    }

    bool set(int& argc, char* argv[], char ch)
    {
      // don't extract value, when already found
      if (m_isset)
        return false;

      for (int i = 1; i < argc; ++i)
        if (argv[i][0] == '-' && argv[i][1] != '-')
        {
          // starts with a '-', but not with "--"
          if (argv[i][1] == ch && argv[i][2] == '\0')
          {
            // single option found
            m_value = true;
            m_isset = true;
            for ( ; i < argc - 1; ++i)
              argv[i] = argv[i + 1];
            argc -= 1;
            argv[argc] = 0;
            return true;
          }
          else if (argv[i][1] == ch && argv[i][2] == '-' && argv[i][3] == '\0')
          {
            // Option was explicitly disabled with -x-
            m_value = false;
            m_isset = true;
            for ( ; i < argc - 1; ++i)
              argv[i] = argv[i + 1];
            argc -= 1;
            argv[argc] = 0;
            return true;
          }
          else
          {
            // look, if we find the option in a optiongroup
            for (char* p = argv[i] + 1; *p != '\0'; ++p)
              if (*p == ch)
              {
                // her it is - extract it
                m_value = true;
                m_isset = true;
                do
                {
                  *p = *(p + 1);
                } while (*p++ != '\0');

                return true;
              }
          }
        }

      return false;
    }

    bool set(int& argc, char* argv[], const char* str)
    {
      // don't extract value, when already found
      if (m_isset)
        return false;

      for (int i = 1; i < argc; ++i)
        if (strcmp(argv[i], str) == 0)
        {
          m_value = true;
          m_isset = true;
          for ( ; i < argc - 1; ++i)
            argv[i] = argv[i + 1];
          argc -= 1;
          argv[argc] = 0;
          return true;
        }

      return false;
    }

    bool isTrue() const   { return m_value; }

    bool isFalse() const  { return !m_value; }

    operator bool() const  { return m_value; }

    bool isSet() const             { return m_isset; }

  private:
    bool m_value;
    bool m_isset;
};


template <>
class Arg<const char*>
{
  public:
    Arg(const char* def = 0)
      : m_value(def),
        m_isset(false)
    { }

    Arg(int& argc, char* argv[], char ch, const char* def = 0)
      : m_value(def),
        m_isset(false)
    {
      m_isset = set(argc, argv, ch);
    }

    Arg(int& argc, char* argv[], const char* str, const char* def = 0)
      : m_value(def),
        m_isset(false)
    {
      m_isset = set(argc, argv, str);
    }

    Arg(int& argc, char* argv[])
      : m_value(0),
        m_isset(false)
    { 
      m_isset = set(argc, argv);
    }

    bool set(int& argc, char* argv[], char ch)
    {
      // don't extract value, when already found
      if (m_isset)
        return false;

      for (int i = 1; i < argc - 1; ++i)
        if (argv[i][0] == '-' && argv[i][1] == ch && argv[i][2] == '\0')
        {
          m_value = argv[i + 1];
          m_isset = true;
          for ( ; i < argc - 2; ++i)
            argv[i] = argv[i + 2];
          argc -= 2;
          argv[argc] = 0;
          return true;
        }

      return false;
    }

    bool set(int& argc, char* argv[], const char* str, const char* def = 0)
    {
      // don't extract value, when already found
      if (m_isset)
        return false;

      for (int i = 1; i < argc - 1; ++i)
        if (strcmp(argv[i], str) == 0)
        {
          m_value = argv[i + 1];
          m_isset = true;
          for ( ; i < argc - 2; ++i)
            argv[i] = argv[i + 2];
          argc -= 2;
          argv[argc] = 0;
          return true;
        }

      return false;
    }

    bool set(int& argc, char* argv[])
    {
      // don't extract value, when already found
      if (m_isset)
        return false;

      if (argc > 1)
      {
        m_value = argv[1];
        m_isset = true;
        for (int i = 1; i < argc - 1; ++i)
          argv[i] = argv[i + 1];
        argc -= 1;
        argv[argc] = 0;
        return true;
      }
      else
        return false;
    }

    const char* getValue() const   { return m_value; }

    operator const char*() const   { return m_value; }

    bool isSet() const             { return m_isset; }

  private:
    const char* m_value;
    bool        m_isset;
};


template <>
class Arg<std::string>
{
  public:
    Arg(const std::string& def = std::string())
      : m_value(def),
        m_isset(false)
    { }

    Arg(int& argc, char* argv[], char ch, const std::string& def = std::string())
      : m_value(def),
        m_isset(false)
    {
      m_isset = set(argc, argv, ch);
    }

    Arg(int& argc, char* argv[], const char* str, const std::string& def = std::string())
      : m_value(def),
        m_isset(false)
    {
      m_isset = set(argc, argv, str);
    }

    Arg(int& argc, char* argv[])
      : m_value(std::string()),
        m_isset(false)
    {
      m_isset = set(argc, argv);
    }

    bool set(int& argc, char* argv[], char ch)
    {
      // don't extract value, when already found
      if (m_isset)
        return false;

      for (int i = 1; i < argc - 1; ++i)
        if (argv[i][0] == '-' && argv[i][1] == ch && argv[i][2] == '\0')
        {
          m_value = argv[i + 1];
          m_isset = true;
          for ( ; i < argc - 2; ++i)
            argv[i] = argv[i + 2];
          argc -= 2;
          argv[argc] = 0;
          return true;
        }

      return false;
    }

    bool set(int& argc, char* argv[], const char* str)
    {
      // don't extract value, when already found
      if (m_isset)
        return false;

      for (int i = 1; i < argc - 1; ++i)
        if (strcmp(argv[i], str) == 0)
        {
          m_value = argv[i + 1];
          m_isset = true;
          for ( ; i < argc - 2; ++i)
            argv[i] = argv[i + 2];
          argc -= 2;
          argv[argc] = 0;
          return true;
        }

      return false;
    }

    bool set(int& argc, char* argv[])
    {
      // don't extract value, when already found
      if (m_isset)
        return false;

      if (argc > 1)
      {
        m_value = argv[1];
        m_isset = true;
        for (int i = 1; i < argc - 1; ++i)
          argv[i] = argv[i + 1];
        argc -= 1;
        argv[argc] = 0;
        return true;
      }
      else
        return false;
    }

    bool setNoOpt(int& argc, char* argv[])
    {
      // don't extract value, when already found
      if (m_isset)
        return false;

      for (int i = 1; i < argc; ++i)
        if (argv[i][0] != '-')
        {
          m_isset = true;
          m_value = argv[i];
          for ( ; i < argc - 1; ++i)
            argv[i] = argv[i + 1];
          --argc;
          argv[argc] = 0;
          return true;
        }

      return false;
    }

    const std::string& getValue() const   { return m_value; }

    operator const std::string&() const   { return m_value; }

    bool isSet() const             { return m_isset; }

  private:
    std::string m_value;
    bool        m_isset;
};

}

#endif // CXXTOOLS_ARG_H

Copyright © 2008 The Tntnet Development Team

Tntnet 1.6