Bytes.h

Go to the documentation of this file.

/*
 * This file is a part of the Biology project by eons LLC.
 * Biology (aka Develop Biology) is a framework for approaching software
 * development from a natural sciences perspective.
 *
 * Copyright (C) 2026 Séon O'Shannon & eons LLC
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Affero General Public License as
 * published by the Free Software Foundation, either version 3 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 Affero General Public License for more details.
 *
 * You should have received a copy of the GNU Affero General Public License
 * along with this program.  If not, see <https://www.gnu.org/licenses/>.
 */
 
#pragma once
 
#include <stddef.h>
#include <iterator>
#include <vector>
 
namespace bio
{
 
class BytesView
{
public:
    BytesView() :
        mData(NULL),
        mSize(0)
    {
    }
 
    BytesView(const void* data, size_t size) :
        mData(static_cast< const unsigned char* >(data)),
        mSize(size)
    {
    }
 
    const unsigned char* Data() const
    {
        return mData;
    }
 
    size_t Size() const
    {
        return mSize;
    }
 
    bool Empty() const
    {
        return mSize == 0;
    }
 
private:
    const unsigned char* mData;
    size_t mSize;
};
 
class Bytes
{
public:
    Bytes()
    {
    }
 
    explicit Bytes(size_t size)
    {
        Resize(size);
    }
 
    Bytes(const void* data, size_t size)
    {
        Assign(data, size);
    }
 
    // Range constructor — stdlib-interop. SFINAE-guarded on
    // iterator_category so it doesn't overload-collide with
    // Bytes(const void*, size_t) on integral arguments
    // (e.g. Bytes(0, 0) would otherwise be ambiguous). The
    // trailing pointer parameter form is C++98-compatible;
    // default-template-args on function templates require C++11.
    template < typename InputIt >
    Bytes(
        InputIt first,
        InputIt last,
        typename ::std::iterator_traits< InputIt >::iterator_category* = 0
    ) :
        mData(first, last)
    {
    }
 
    const unsigned char* Data() const
    {
        if (mData.empty())
        {
            return NULL;
        }
        return &mData[0];
    }
 
    unsigned char* Data()
    {
        if (mData.empty())
        {
            return NULL;
        }
        return &mData[0];
    }
 
    size_t Size() const
    {
        return mData.size();
    }
 
    bool Empty() const
    {
        return mData.empty();
    }
 
    void Clear()
    {
        mData.clear();
    }
 
    void Resize(size_t size)
    {
        mData.resize(size, 0);
    }
 
    void Assign(const void* data, size_t size)
    {
        const unsigned char* bytes = static_cast< const unsigned char* >(data);
        if (!bytes || size == 0)
        {
            mData.clear();
            return;
        }
        mData.assign(bytes, bytes + size);
    }
 
    void Append(const void* data, size_t size)
    {
        const unsigned char* bytes = static_cast< const unsigned char* >(data);
        if (!bytes || size == 0)
        {
            return;
        }
        mData.insert(mData.end(), bytes, bytes + size);
    }
 
    BytesView View() const
    {
        return BytesView(Data(), Size());
    }
 
    bool operator==(const Bytes& other) const
    {
        return mData == other.mData;
    }
 
    bool operator!=(const Bytes& other) const
    {
        return !(*this == other);
    }
 
    // ----------------------------------------------------------------------
    // Stdlib-interop API
    //
    // Naming exception to bio's house style (capitalized methods): these
    // must be lowercase because they are compile-time hooks for the C++
    // standard library — range-for resolves `for (x : c)` to `c.begin()`
    // / `c.end()` by EXACT name, and std::iterator_traits / std-algorithms
    // look for `value_type`, `iterator`, etc. by exact name. Capitalized
    // aliases would not satisfy these resolutions, defeating the purpose.
    //
    // The capitalized API above stays canonical for bio's own consumers;
    // these are purely stdlib drop-in compatibility.
    // ----------------------------------------------------------------------
 
    typedef unsigned char value_type;
    typedef unsigned char* iterator;
    typedef const unsigned char* const_iterator;
    typedef size_t size_type;
    typedef ::std::ptrdiff_t difference_type;
 
    iterator begin()             { return mData.data(); }
    iterator end()               { return mData.data() + mData.size(); }
    const_iterator begin() const { return mData.data(); }
    const_iterator end()   const { return mData.data() + mData.size(); }
    const_iterator cbegin() const { return mData.data(); }
    const_iterator cend()   const { return mData.data() + mData.size(); }
 
    unsigned char& operator[](size_type i)             { return mData[i]; }
    const unsigned char& operator[](size_type i) const { return mData[i]; }
 
    void reserve(size_type n) { mData.reserve(n); }
    void push_back(unsigned char b) { mData.push_back(b); }
 
private:
    ::std::vector< unsigned char > mData;
};
 
} //bio namespace