validator_size.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/validator_size.h"
 
#include    "advgetopt/validator_double.h"
 
 
// cppthread
//
#include    <cppthread/log.h>
 
 
// snapdev
//
#include    <snapdev/int128_literal.h>
#include    <snapdev/math.h>
 
 
// last include
//
#include    <snapdev/poison.h>
 
 
 
 
namespace advgetopt
{
 
 
 
namespace
{
 
 
 
class validator_size_factory
    : public validator_factory
{
public:
    validator_size_factory()
    {
        validator::register_validator(*this);
    }
 
    virtual std::string get_name() const override
    {
        return std::string("size");
    }
 
    virtual std::shared_ptr<validator> create(string_list_t const & data) const override
    {
        return std::make_shared<validator_size>(data);
    }
};
 
validator_size_factory      g_validator_size_factory;
 
 
 
} // no name namespace
 
 
 
 
 
validator_size::validator_size(string_list_t const & flag_list)
{
    for(auto r : flag_list)
    {
        if(r == "si")
        {
            f_flags &= ~VALIDATOR_SIZE_POWER_OF_TWO;
        }
        else if(r == "legacy")
        {
            f_flags |= VALIDATOR_SIZE_POWER_OF_TWO;
        }
        else
        {
            cppthread::log << cppthread::log_level_t::error
                           << r
                           << " is not a valid flag for the size validator."
                           << cppthread::end;
            continue;
        }
    }
}
 
 
std::string validator_size::name() const
{
    return std::string("size");
}
 
 
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wpedantic"
bool validator_size::validate(std::string const & value) const
{
    using namespace snapdev::literals;
    __int128 result(0_int128);
    if(convert_string(value, f_flags, result))
    {
        return true;
    }
 
    set_error("invalid size suffix or number.");
    return false;
}
#pragma GCC diagnostic pop
 
 
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wpedantic"
bool validator_size::convert_string(
          std::string const & value
        , flag_t flags
        , __int128 & result)
{
    using namespace snapdev::literals;
 
    // determine the factor by checking the suffix
    //
    __int128 factor(1_int128);
    std::string::size_type pos(value.length());
    for(; pos > 0; --pos)
    {
        char c(value[pos - 1]);
        if(c >= '0'
        && c <= '9'
        || c == '.')
        {
            break;
        }
    }
    if(pos == 0)
    {
        return false;
    }
    __int128 const base(
        (flags & VALIDATOR_SIZE_POWER_OF_TWO) != 0
            ? 1024_int128
            : 1000_int128);
    std::string const number(value.substr(0, pos));
    for(; pos < value.length() && isspace(value[pos]); ++pos);
    if(pos < value.length())
    {
        // copy and force lowercase (although the case is important
        // when writing such a measurement, it does not matter when
        // testing here)
        //
        std::string suffix;
        for(; pos < value.length(); ++pos)
        {
            if(value[pos] >= 'A'
            && value[pos] <= 'Z')
            {
                suffix += value[pos] + 0x20;
            }
            else
            {
                suffix += value[pos];
            }
        }
 
        switch(suffix[0])
        {
        case 'b':
            if(suffix != "b")
            {
                return false;
            }
            break;
 
        case 'e':
            if(suffix == "eb")
            {
                factor = snapdev::pow(base, 6);
            }
            else if(suffix == "eib")
            {
                factor = snapdev::pow(1024_int128, 6);
            }
            else
            {
                return false;
            }
            break;
 
        case 'g':
            if(suffix == "gb")
            {
                factor = snapdev::pow(base, 3);
            }
            else if(suffix == "gib")
            {
                factor = snapdev::pow(1024_int128, 3);
            }
            else
            {
                return false;
            }
            break;
 
        case 'k':
            if(suffix == "kb")
            {
                factor = base;
            }
            else if(suffix == "kib")
            {
                factor = 1024_int128;
            }
            else
            {
                return false;
            }
            break;
 
        case 'm':
            if(suffix == "mb")
            {
                factor = snapdev::pow(base, 2);
            }
            else if(suffix == "mib")
            {
                factor = snapdev::pow(1024_int128, 2);
            }
            else
            {
                return false;
            }
            break;
 
        case 'p':
            if(suffix == "pb")
            {
                factor = snapdev::pow(base, 5);
            }
            else if(suffix == "pib")
            {
                factor = snapdev::pow(1024_int128, 5);
            }
            else
            {
                return false;
            }
            break;
 
        case 'q':
            if(suffix == "qb")
            {
                factor = snapdev::pow(base, 10);
            }
            else if(suffix == "qib")
            {
                factor = snapdev::pow(1024_int128, 10);
            }
            else
            {
                return false;
            }
            break;
 
        case 'r':
            if(suffix == "rb")
            {
                factor = snapdev::pow(base, 9);
            }
            else if(suffix == "rib")
            {
                factor = snapdev::pow(1024_int128, 9);
            }
            else
            {
                return false;
            }
            break;
 
        case 't':
            if(suffix == "tb")
            {
                factor = snapdev::pow(base, 4);
            }
            else if(suffix == "tib")
            {
                factor = snapdev::pow(1024_int128, 4);
            }
            else
            {
                return false;
            }
            break;
 
        case 'y':
            if(suffix == "yb")
            {
                factor = snapdev::pow(base, 8);
            }
            else if(suffix == "yib")
            {
                factor = snapdev::pow(1024_int128, 8);
            }
            else
            {
                return false;
            }
            break;
 
        case 'z':
            if(suffix == "zb")
            {
                factor = snapdev::pow(base, 7);
            }
            else if(suffix == "zib")
            {
                factor = snapdev::pow(1024_int128, 7);
            }
            else
            {
                return false;
            }
            break;
 
        default:
            return false;
 
        }
    }
 
    double base_number(0.0);
    if(!validator_double::convert_string(number, base_number))
    {
        return false;
    }
 
    // TODO: I think that even with the long double this will lose bits
    result = static_cast<long double>(base_number) * factor;
 
    return true;
}
#pragma GCC diagnostic pop
 
 
 
} // namespace advgetopt
// vim: ts=4 sw=4 et