DataSize.hpp

Go to the documentation of this file.

/*
 * This file is part of the DUDS project. It is subject to the BSD-style
 * license terms in the LICENSE file found in the top-level directory of this
 * distribution and at https://github.com/jjackowski/duds/blob/master/LICENSE.
 * No part of DUDS, including this file, may be copied, modified, propagated,
 * or distributed except according to the terms contained in the LICENSE file.
 *
 * Copyright (C) 2018  Jeff Jackowski
 */
#ifndef DATASIZES_HPP
#define DATASIZES_HPP

#include <duds/general/Errors.hpp>
#include <cstdint>

namespace duds { namespace general {

struct DataSizeConversionError : virtual std::exception, virtual boost::exception { };

typedef boost::error_info<struct Info_DataSizeSourceUnit, std::size_t>
    DataSizeSourceUnit;

typedef boost::error_info<struct Info_DataSizeTargetUnit, std::size_t>
    DataSizeTargetUnit;

typedef boost::error_info<struct Info_DataSizeBlocks, std::size_t>
    DataSizeBlocks;

#if defined(DUDS_ERRORS_VERBOSE) || defined(DOXYGEN)

#define THROW_DATASIZE_CONVERSION_ERROR(bits, trgbits, blocks)  \
    throw boost::enable_current_exception(DataSizeConversionError()) << \
            DataSizeSourceUnit(bits) << DataSizeTargetUnit(trgbits) << \
            DataSizeBlocks(blocks) << \
            boost::throw_function(BOOST_CURRENT_FUNCTION) << \
            boost::throw_file(__FILE__) << ::boost::throw_line((int)__LINE__) << \
            duds::general::StackTrace(boost::stacktrace::stacktrace())
#else
#define THROW_DATASIZE_CONVERSION_ERROR(bits, trgbits, blocks)  \
    throw boost::enable_current_exception(DataSizeConversionError()) << \
            DataSizeSourceUnit(bits) << DataSizeTargetUnit(trgbits) << \
            DataSizeBlocks(blocks) << \
            boost::throw_function(BOOST_CURRENT_FUNCTION) << \
            boost::throw_file(__FILE__) << ::boost::throw_line((int)__LINE__)
#endif

template <std::size_t Bits>
class DataSize {
    std::size_t numblocks;
public:
    static constexpr std::size_t blockSize() {
        return Bits;
    }
    DataSize() = default;
    constexpr DataSize(std::size_t blocks) : numblocks(blocks) { }
    template <std::size_t ConvBits>
    constexpr DataSize(const DataSize<ConvBits> &ds) :
    numblocks(
        // the throw prevents compilation when the conditional is false and
        // this function is used in a constexpr expression
        (ds.bits() % Bits) ?
        THROW_DATASIZE_CONVERSION_ERROR(ConvBits, Bits, ds.blocks()) :
        (ds.bits() / Bits)
    ) { }
    constexpr std::size_t blocks() const {
        return numblocks;
    }
    constexpr std::uint64_t bits() const {
        return (std::uint64_t)numblocks * (std::uint64_t)Bits;
    }
    template <class OtherDataSize>
    constexpr OtherDataSize size() const {
        // the throw prevents compilation when the conditional is false and
        // this function is used in a constexpr expression
        return (bits() % OtherDataSize::blockSize()) ?
        THROW_DATASIZE_CONVERSION_ERROR(Bits, OtherDataSize::blockSize(), numblocks) :
        OtherDataSize(bits() / OtherDataSize::blockSize());
    }
    template <std::size_t ConvBits>
    constexpr operator DataSize<ConvBits>() const {
        return size<ConvBits>();
    }
    template <class OtherDataSize>
    constexpr OtherDataSize sizeRounded() const {
        return OtherDataSize(
            (bits() / OtherDataSize::blockSize()) +
            ((bits() % OtherDataSize::blockSize()) ? 1 : 0)
        );
    }
    constexpr std::uint64_t bytes() const {
        return size< DataSize<8> >().blocks();
    }
    constexpr std::uint64_t bytesRounded() const {
        return sizeRounded< DataSize<8> >().blocks();
    }
    template <std::size_t OtherBits>
    constexpr bool operator == (const DataSize<OtherBits> &op) const {
        return bits() == op.bits();
    }
    template <std::size_t OtherBits>
    constexpr bool operator != (const DataSize<OtherBits> &op) const {
        return bits() != op.bits();
    }
    template <std::size_t OtherBits>
    constexpr bool operator > (const DataSize<OtherBits> &op) const {
        return bits() > op.bits();
    }
    template <std::size_t OtherBits>
    constexpr bool operator < (const DataSize<OtherBits> &op) const {
        return bits() < op.bits();
    }
    template <std::size_t OtherBits>
    constexpr bool operator >= (const DataSize<OtherBits> &op) const {
        return bits() >= op.bits();
    }
    template <std::size_t OtherBits>
    constexpr bool operator <= (const DataSize<OtherBits> &op) const {
        return bits() <= op.bits();
    }
    constexpr DataSize operator + (const DataSize &op) const {
        return DataSize(numblocks + op.numblocks);
    }
    constexpr DataSize operator - (const DataSize &op) const {
        return DataSize(numblocks - op.numblocks);
    }
    DataSize &operator += (const DataSize &op) {
        numblocks += op.numblocks;
        return *this;
    }
    DataSize &operator -= (const DataSize &op) {
        numblocks -= op.numblocks;
        return *this;
    }
    constexpr DataSize operator * (int scalar) const {
        return DataSize(numblocks * scalar);
    }
    constexpr DataSize operator / (int scalar) const {
        return DataSize(numblocks / scalar);
    }
    DataSize &operator *= (int scalar) {
        numblocks *= scalar;
        return *this;
    }
    DataSize &operator /= (int scalar) {
        numblocks /= scalar;
        return *this;
    }
};

typedef DataSize<1> Bits;

typedef DataSize<4> Nibbles;

typedef DataSize<8> Bytes;

typedef DataSize<1024*8> Kilobytes;

typedef DataSize<1024*1024*8> Megabytes;

typedef DataSize<1000> Kilobits;

typedef DataSize<1000000> Megabits;

typedef DataSize<1000000000> Gigabits;

} }

#endif        //  #ifndef DATASIZES_HPP