EntryModel.hxx

Go to the documentation of this file.

 
#ifndef _UTILS_ENTRYMODEL_HXX_
#define _UTILS_ENTRYMODEL_HXX_
 
#include <algorithm>
#include <cstring>
#include <functional>
#include <type_traits>
#include <limits>
 
#include "utils/format_utils.hxx"
 
template <class T>
class EntryModel
{
public:
    EntryModel()
        : value_(0)
        , valueMin_(std::numeric_limits<T>::lowest())
        , valueMax_(std::numeric_limits<T>::max())
        , numLeadingZeros_(0)
        , maxSize_(0)
        , size_(0)
        , isAtInitialValue_(false)
        , empty_(true)
        , base_(10)
        , autoClamp_(true)
    {
    }
 
    void clear()
    {
        value_ = 0;
        numLeadingZeros_ = 0;
        size_ = 0;
        empty_ = true;
        isAtInitialValue_ = false;
    }
 
    void init(unsigned max_size, int base)
    {
        maxSize_ = max_size;
        autoClamp_ = true;
        clear();
        set_base(base); // this will call set_boundaries()
    }
 
    void init(unsigned max_size, int base, T value, bool automatic_clamp = true)
    {
        init(max_size, base);
        autoClamp_ = automatic_clamp;
        value_ = value;
        isAtInitialValue_ = true;
        empty_ = false;
    }
 
    void push_back(uint8_t val)
    {
        HASSERT(val < base_);
        if (size_ >= maxSize_)
        {
            // clear entry, return without appending the character
            clear();
            return;
        }
        if (isAtInitialValue_)
        {
            // clear entry before inserting character
            clear();
        }
        if (value_ == 0 && val != 0 && size_)
        {
            // This is a special case where we transition from a user having
            // entered all 0 (as a first digits) and then enters a non-zero
            // (as a next digit).
            ++numLeadingZeros_;
        }
        value_ *= base_;
        if (value_ < 0)
        {
            value_ -= val;
        }
        else
        {
            value_ += val;
        }
        if (value_ == 0 && !empty_)
        {
            if (numLeadingZeros_ < 31)
            {
                ++numLeadingZeros_;
            }
        }
        empty_ = false;
        ++size_;
        auto_clamp();
    }
 
    void push_back_char(char c)
    {
        switch (base_)
        {
            case 10:
                push_back(c - '0');
                break;
            case 16:
                c = toupper(c);
                push_back(c <= '9' ?  c - '0' : c - 'A' + 10);
                break;
        }
    }
 
    EntryModel &append(uint8_t val)
    {
        push_back(val);
        return *this;
    }
 
    EntryModel &append_char(char c)
    {
        push_back_char(c);
        return *this;
    }
 
    void pop_back()
    {
        value_ /= base_;
        if (value_ == 0 && numLeadingZeros_)
        {
            --numLeadingZeros_;
        }
        if (size_)
        {
            --size_;
        }
        if (isAtInitialValue_)
        {
            isAtInitialValue_ = false;
            auto_clamp();
            // need to compute the size now that the initial value is false
            calculate_size();
        }
        if (size_ == 0)
        {
            // no more characters left, so the entry is "empty"
            empty_ = true;
        }
        auto_clamp();
    }
 
    void set_base(int base)
    {
        HASSERT(base == 10 || base == 16);
        base_ = base;
        set_boundaries();
    }
 
    void set_base(int base, bool convert)
    {
        if (base != base_)
        {
            if (convert)
            {
                string str = get_string();
                if (std::is_signed<T>::value)
                {
                    value_ = strtoll(str.c_str(), nullptr, base);
                }
                else
                {
                    value_ = strtoull(str.c_str(), nullptr, base);
                }
            }
            set_base(base);
        }
    }
 
    void set_value(T value)
    {
        init(maxSize_, base_, value, autoClamp_);
    }
 
    size_t size()
    {
        return size_;
    }
 
    size_t max_size()
    {
        return maxSize_;
    }
 
    bool empty()
    {
        return (!isAtInitialValue_ && empty_);
    }
 
    bool cursor_visible()
    {
        return size_ < maxSize_;
    }
 
    bool is_at_initial_value()
    {
        return isAtInitialValue_;
    }
 
    bool has_leading_zeros()
    {
        return numLeadingZeros_ > 0;
    }
 
    void set_leading_zeros(unsigned num)
    {
        numLeadingZeros_ = num;
    }
 
    T get_value(bool force_clamp = false)
    {
        if (force_clamp)
        {
            clamp(true);
        }
        return value_;
    }
 
    string get_string(bool right_justify = false)
    {
        string str;
        if (isAtInitialValue_ || !empty_)
        {
            switch (base_)
            {
                default:
                    // should never get here.
                    break;
                case 10:
                    if (std::is_signed<T>::value)
                    {
                        str = int64_to_string(value_);
                    }
                    else
                    {
                        str = uint64_to_string(value_);
                    }
                    break;
                case 16:
                    if (std::is_signed<T>::value)
                    {
                        str = int64_to_string_hex(value_);
                    }
                    else
                    {
                        str = uint64_to_string_hex(value_);
                    }
                    // requires all characters in upper case
                    transform(str.begin(), str.end(), str.begin(), toupper);
                    break;
            }
        }
 
        if (numLeadingZeros_)
        {
            str.insert(value_ < 0 ? 1 : 0, numLeadingZeros_, '0');
        }
        if (right_justify && str.size() < maxSize_)
        {
            str.insert(0, maxSize_ - str.size(), ' ');
        }
        return str;
    }
    
    void set_min()
    {
        set_value(valueMin_);
    }
 
    void set_max()
    {
        set_value(valueMax_);
    }
 
    void change_sign()
    {
        if (value_ < 0)
        {
            --size_;
        }
        value_ = -value_;
        if (value_ < 0)
        {
            ++size_;
        }
        auto_clamp();
    }
 
    virtual void clamp(bool force = false)
    {
        if (value_ == 0 && size_ < maxSize_ && !force)
        {
            // skip clamping if we have space for more leading zeros
            return;
        }
        if (force || !empty_)
        {
            empty_ = false;
            if (value_ < valueMin_)
            {
                value_ = valueMin_;
                calculate_size();
            }
            else if (value_ > valueMax_)
            {
                value_ = valueMax_;
                calculate_size();
            }
        }
    }
 
    T operator ++()
    {
        isAtInitialValue_ = false;
        if (value_ < std::numeric_limits<T>::max())
        {
            ++value_;
        }
        clamp();
        return value_;
    }
 
    T operator --()
    {
        isAtInitialValue_ = false;
        if (value_ > std::numeric_limits<T>::lowest())
        {
            --value_;
        }
        clamp();
        return value_;
    }
 
protected:
    void auto_clamp(bool force = false)
    {
        if (autoClamp_)
        {
            clamp(force);
        }
    }
 
    virtual void set_boundaries()
    {
        valueMax_ = 0;
        for (unsigned i = 0; i < maxSize_; ++i)
        {
            valueMax_ *= base_;
            valueMax_ += base_ - 1;
        }
        valueMin_ = std::is_signed<T>::value ? valueMax_ / -base_ : 0;
    }
 
    void calculate_size()
    {
        // calculate new size_
        size_ = value_ < 0 ? 1 : 0;
        for (T tmp = value_ < 0 ? -value_ : value_; tmp != 0; tmp /= base_)
        {
            ++size_;
        }
        numLeadingZeros_ = std::min(static_cast<unsigned>(numLeadingZeros_),
                                    static_cast<unsigned>(maxSize_ - size_));
        size_ += numLeadingZeros_;
    }
 
    T value_; 
    T valueMin_; 
    T valueMax_; 
 
    unsigned numLeadingZeros_  : 5; 
    unsigned maxSize_          : 5; 
    unsigned size_             : 5; 
    unsigned isAtInitialValue_ : 1; 
    unsigned empty_            : 1; 
    unsigned base_             : 6; 
    unsigned autoClamp_        : 1; 
 
    DISALLOW_COPY_AND_ASSIGN(EntryModel);
};
 
template <class T> class EntryModelBounded : public EntryModel<T>
{
public:
    EntryModelBounded()
        : EntryModel<T>()
    {
    }
 
    void init(unsigned max_size, int base, T value, T min, T max, T default_val,
              bool automatic_clamp = true)
    {
        // purposely do not boundary check the min, max, and default values
        EntryModel<T>::init(max_size, base, value, automatic_clamp);
        // override type min/max values
        EntryModel<T>::valueMin_ = min;
        EntryModel<T>::valueMax_ = max;
        valueDefault_ = default_val;
    }
 
    void set_default()
    {
        EntryModel<T>::set_value(valueDefault_);
    }
 
private:
    void clamp(bool force = false) override
    {
        if (force && EntryModel<T>::empty_)
        {
            set_default();
        }
        else
        {
            EntryModel<T>::clamp(force);
        }
    }
 
    void set_boundaries() override
    {
    }
 
    T valueDefault_; 
 
    DISALLOW_COPY_AND_ASSIGN(EntryModelBounded);
};
 
#endif // _UTILS_ENTRYMODEL_HXX_