Bytes.hpp

// -*- C++ -*-
/*
 *    Copyright (C) 2021 Joshua Boudreau <jboudreau@45drives.com>
 *
 *    This file is part of lib45d.
 *
 *    lib45d 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 3 of the License, or
 *    (at your option) any later version.
 *
 *    lib45d 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 lib45d.  If not, see <https://www.gnu.org/licenses/>.
 */
 
#pragma once
 
#include <cmath>
#include <iostream>
#include <string>
 
namespace ffd {
    class Bytes {
    public:
        typedef off64_t bytes_type;     
        enum PrefixType { BINARY, SI }; 
 
        Bytes(const std::string &str);
        Bytes(bytes_type bytes) : bytes_(bytes) {}
        Bytes(void) : bytes_(0) {}
        Bytes(const Bytes &other) : bytes_(other.get()) {}
        Bytes(Bytes &&other) : bytes_(std::move(other.bytes_)) {}
        Bytes &operator=(const Bytes &other) {
            bytes_ = other.get();
            return *this;
        }
        Bytes &operator=(Bytes &&other) {
            bytes_ = std::move(other.bytes_);
            return *this;
        }
        ~Bytes() = default;
        virtual bytes_type get(void) const {
            return bytes_;
        }
        std::string get_str(enum PrefixType prefix_type = BINARY, int precision = 2) const;
        void set(bytes_type val) {
            bytes_ = val;
        }
        void set(const std::string &str) {
            bytes_ = parse_bytes(str);
        }
        friend std::ostream &operator<<(std::ostream &os, Bytes const &bytes) {
            return os << bytes.get_str();
        }
        friend std::istream &operator>>(std::istream &is, Bytes &bytes) {
            std::string str;
            std::getline(is, str);
            bytes.set(str);
            return is;
        }
        Bytes &operator+=(const Bytes &other) {
            bytes_ += other.get();
            return *this;
        }
        Bytes &operator-=(const Bytes &other) {
            bytes_ -= other.get();
            return *this;
        }
        friend Bytes operator+(const Bytes &a, const Bytes &b) {
            return Bytes(a.get() + b.get());
        }
        friend Bytes operator-(const Bytes &a, const Bytes &b) {
            return Bytes(a.get() - b.get());
        }
        friend Bytes operator*(const Bytes &a, int b) {
            return Bytes(a.get() * b);
        }
        friend Bytes operator*(int a, const Bytes &b) {
            return b * a;
        }
        friend Bytes operator/(const Bytes &a, int b) {
            return Bytes(a.get() / b);
        }
        friend double operator/(const Bytes &a, const Bytes &b) {
            return double(a.get()) / double(b.get());
        }
        friend bool operator==(const Bytes &a, const Bytes &b) {
            return a.get() == b.get();
        }
        friend bool operator!=(const Bytes &a, const Bytes &b) {
            return !(operator==(a, b));
        }
        friend bool operator<(const Bytes &a, const Bytes &b) {
            return a.get() < b.get();
        }
        friend bool operator>(const Bytes &a, const Bytes &b) {
            return b.get() < a.get();
        }
        friend bool operator<=(const Bytes &a, const Bytes &b) {
            return !(operator>(a, b));
        }
        friend bool operator>=(const Bytes &a, const Bytes &b) {
            return !(operator<(a, b));
        }
    protected:
        bytes_type bytes_; 
 
        bytes_type parse_bytes(const std::string &str) const;
    };
} // namespace ffd