option_info_ref.cpp

Go to the documentation of this file.

// Copyright (c) 2006-2025  Made to Order Software Corp.  All Rights Reserved
//
// https://snapwebsites.org/project/advgetopt
// contact@m2osw.com
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// This program 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 General Public License for more details.
//
// You should have received a copy of the GNU General Public License along
// with this program; if not, write to the Free Software Foundation, Inc.,
// 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 
 
// self
//
#include    "advgetopt/option_info.h"
 
#include    "advgetopt/exception.h"
#include    "advgetopt/validator_double.h"
#include    "advgetopt/validator_integer.h"
 
 
// cppthread
//
#include    <cppthread/log.h>
 
 
// libutf8
//
#include    <libutf8/libutf8.h>
 
 
// last include
//
#include    <snapdev/poison.h>
 
 
 
namespace advgetopt
{
 
 
 
option_info_ref::option_info_ref(option_info::pointer_t opt)
    : f_opt(opt)
{
}
 
 
bool option_info_ref::empty() const
{
    if(f_opt->is_defined())
    {
        return f_opt->get_value().empty();
    }
 
    return true;
}
 
 
size_t option_info_ref::length() const
{
    if(f_opt->is_defined())
    {
        return f_opt->get_value().length();
    }
 
    return f_opt->get_default().length();
}
 
 
size_t option_info_ref::size() const
{
    return length();
}
 
 
long option_info_ref::get_long() const
{
    if(f_opt->is_defined())
    {
        return f_opt->get_long();
    }
 
    if(!f_opt->has_default())
    {
        return 0;
    }
 
    std::int64_t v;
    if(!validator_integer::convert_string(f_opt->get_default(), v))
    {
        cppthread::log << cppthread::log_level_t::error
                       << "invalid default value for a number ("
                       << f_opt->get_default()
                       << ") in parameter --"
                       << f_opt->get_name()
                       << " at offset 0."
                       << cppthread::end;
        return -1;
    }
 
    return v;
}
 
 
double option_info_ref::get_double() const
{
    if(f_opt->is_defined())
    {
        return f_opt->get_double();
    }
 
    if(!f_opt->has_default())
    {
        return 0.0;
    }
 
    double v;
    if(!validator_double::convert_string(f_opt->get_default(), v))
    {
        cppthread::log << cppthread::log_level_t::error
                       << "invalid default value as a double number ("
                       << f_opt->get_default()
                       << ") in parameter --"
                       << f_opt->get_name()
                       << " at offset 0."
                       << cppthread::end;
        return -1.0;
    }
 
    return v;
}
 
 
option_info_ref::operator std::string () const
{
    if(f_opt->is_defined())
    {
        return f_opt->get_value();
    }
 
    return f_opt->get_default();
}
 
 
option_info_ref & option_info_ref::operator = (char value)
{
    std::string v;
    if(value != '\0')
    {
        v += value;
    }
    f_opt->set_value(0, v); // source considered DIRECT
    return *this;
}
 
 
option_info_ref & option_info_ref::operator = (char32_t value)
{
    std::string v;
    if(value != U'\0')
    {
        v = libutf8::to_u8string(value);
    }
    f_opt->set_value(0, v); // source considered DIRECT
    return *this;
}
 
 
option_info_ref & option_info_ref::operator = (char const * value)
{
    if(value == nullptr)
    {
        f_opt->set_value(0, std::string()); // source considered DIRECT
    }
    else
    {
        f_opt->set_value(0, value); // source considered DIRECT
    }
    return *this;
}
 
 
option_info_ref & option_info_ref::operator = (std::string const & value)
{
    f_opt->set_value(0, value); // source considered DIRECT
    return *this;
}
 
 
option_info_ref & option_info_ref::operator = (option_info_ref const & value)
{
    f_opt->set_value(0, value); // source considered DIRECT
    return *this;
}
 
 
option_info_ref & option_info_ref::operator += (char value)
{
    std::string v;
    if(value != '\0')
    {
        v += value;
    }
    f_opt->set_value(0, static_cast<std::string>(*this) + v); // source considered DIRECT
    return *this;
}
 
 
option_info_ref & option_info_ref::operator += (char32_t value)
{
    std::string v;
    if(value != '\0')
    {
        v += libutf8::to_u8string(value);
    }
    f_opt->set_value(0, static_cast<std::string>(*this) + v); // source considered DIRECT
    return *this;
}
 
 
option_info_ref & option_info_ref::operator += (char const * value)
{
    std::string v;
    if(value != nullptr)
    {
        v = value;
    }
    f_opt->set_value(0, static_cast<std::string>(*this) + v); // source considered DIRECT
    return *this;
}
 
 
option_info_ref & option_info_ref::operator += (std::string const & value)
{
    f_opt->set_value(0, static_cast<std::string>(*this) + value); // source considered DIRECT
    return *this;
}
 
 
option_info_ref & option_info_ref::operator += (option_info_ref const & value)
{
    f_opt->set_value( // source considered DIRECT
              0
            , static_cast<std::string>(*this) + static_cast<std::string>(value));
    return *this;
}
 
 
std::string option_info_ref::operator + (char value) const
{
    return static_cast<std::string>(*this) + value;
}
 
 
std::string option_info_ref::operator + (char32_t value) const
{
    return static_cast<std::string>(*this) + libutf8::to_u8string(value);
}
 
 
std::string option_info_ref::operator + (char const * value) const
{
    if(value == nullptr)
    {
        return *this;
    }
    return static_cast<std::string>(*this) + value;
}
 
 
std::string option_info_ref::operator + (std::string const & value) const
{
    return static_cast<std::string>(*this) + value;
}
 
 
std::string option_info_ref::operator + (option_info_ref const & value) const
{
    return static_cast<std::string>(*this)
         + static_cast<std::string>(value);
}
 
 
std::string operator + (char value, option_info_ref const & rhs)
{
    return value + static_cast<std::string>(rhs);
}
 
 
std::string operator + (char32_t value, option_info_ref const & rhs)
{
    return libutf8::to_u8string(value) + static_cast<std::string>(rhs);
}
 
 
std::string operator + (char const * value, option_info_ref const & rhs)
{
    if(value == nullptr)
    {
        return rhs;
    }
    return value + static_cast<std::string>(rhs);
}
 
 
std::string operator + (std::string const & value, option_info_ref const & rhs)
{
    return value + static_cast<std::string>(rhs);
}
 
 
option_info_ref::operator bool () const
{
    return !empty();
}
 
 
bool option_info_ref::operator ! () const
{
    return empty();
}
 
 
bool option_info_ref::operator == (char const * value) const
{
    if(value == nullptr)
    {
        return empty();
    }
    return static_cast<std::string>(*this) == value;
}
 
 
bool option_info_ref::operator == (std::string const & value) const
{
    return static_cast<std::string>(*this) == value;
}
 
 
bool option_info_ref::operator == (option_info_ref const & value) const
{
    return static_cast<std::string>(*this) == static_cast<std::string>(value);
}
 
 
bool option_info_ref::operator != (char const * value) const
{
    if(value == nullptr)
    {
        return !empty();
    }
    return static_cast<std::string>(*this) != value;
}
 
 
bool option_info_ref::operator != (std::string const & value) const
{
    return static_cast<std::string>(*this) != value;
}
 
 
bool option_info_ref::operator != (option_info_ref const & value) const
{
    return static_cast<std::string>(*this) != static_cast<std::string>(value);
}
 
 
bool option_info_ref::operator < (char const * value) const
{
    if(value == nullptr)
    {
        return false;
    }
    return static_cast<std::string>(*this) < value;
}
 
 
bool option_info_ref::operator < (std::string const & value) const
{
    return static_cast<std::string>(*this) < value;
}
 
 
bool option_info_ref::operator < (option_info_ref const & value) const
{
    return static_cast<std::string>(*this) < static_cast<std::string>(value);
}
 
 
bool option_info_ref::operator <= (char const * value) const
{
    if(value == nullptr)
    {
        return empty();
    }
    return static_cast<std::string>(*this) <= value;
}
 
 
bool option_info_ref::operator <= (std::string const & value) const
{
    return static_cast<std::string>(*this) <= value;
}
 
 
bool option_info_ref::operator <= (option_info_ref const & value) const
{
    return static_cast<std::string>(*this) <= static_cast<std::string>(value);
}
 
 
bool option_info_ref::operator > (char const * value) const
{
    if(value == nullptr)
    {
        return !empty();
    }
    return static_cast<std::string>(*this) > value;
}
 
 
bool option_info_ref::operator > (std::string const & value) const
{
    return static_cast<std::string>(*this) > value;
}
 
 
bool option_info_ref::operator > (option_info_ref const & value) const
{
    return static_cast<std::string>(*this) > static_cast<std::string>(value);
}
 
 
bool option_info_ref::operator >= (char const * value) const
{
    if(value == nullptr)
    {
        return true;
    }
    return static_cast<std::string>(*this) >= value;
}
 
 
bool option_info_ref::operator >= (std::string const & value) const
{
    return static_cast<std::string>(*this) >= value;
}
 
 
bool option_info_ref::operator >= (option_info_ref const & value) const
{
    return static_cast<std::string>(*this) >= static_cast<std::string>(value);
}
 
 
 
bool operator == (char const * value, option_info_ref const & rhs)
{
    if(value == nullptr)
    {
        return rhs.empty();
    }
    return value == static_cast<std::string>(rhs);
}
 
 
bool operator == (std::string const & value, option_info_ref const & rhs)
{
    return value == static_cast<std::string>(rhs);
}
 
 
bool operator != (char const * value, option_info_ref const & rhs)
{
    if(value == nullptr)
    {
        return !rhs.empty();
    }
    return value != static_cast<std::string>(rhs);
}
 
 
bool operator != (std::string const & value, option_info_ref const & rhs)
{
    return value != static_cast<std::string>(rhs);
}
 
 
bool operator < (char const * value, option_info_ref const & rhs)
{
    if(value == nullptr)
    {
        return !rhs.empty();
    }
    return value < static_cast<std::string>(rhs);
}
 
 
bool operator < (std::string const & value, option_info_ref const & rhs)
{
    return value < static_cast<std::string>(rhs);
}
 
 
bool operator <= (char const * value, option_info_ref const & rhs)
{
    if(value == nullptr)
    {
        return true;
    }
    return value <= static_cast<std::string>(rhs);
}
 
 
bool operator <= (std::string const & value, option_info_ref const & rhs)
{
    return value <= static_cast<std::string>(rhs);
}
 
 
bool operator > (char const * value, option_info_ref const & rhs)
{
    if(value == nullptr)
    {
        return false;
    }
    return value > static_cast<std::string>(rhs);
}
 
 
bool operator > (std::string const & value, option_info_ref const & rhs)
{
    return value > static_cast<std::string>(rhs);
}
 
 
bool operator >= (char const * value, option_info_ref const & rhs)
{
    if(value == nullptr)
    {
        return rhs.empty();
    }
    return value >= static_cast<std::string>(rhs);
}
 
 
bool operator >= (std::string const & value, option_info_ref const & rhs)
{
    return value >= static_cast<std::string>(rhs);
}
 
 
 
}   // namespace advgetopt
 
 
 
// vim: ts=4 sw=4 et