IsMemcpySafe.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 "bio/common/macro/Macros.h"
#include "bio/common/type/IsPointer.h"
#include "bio/common/type/IsPrimitive.h"
 
namespace bio {
 
class String;
class Bytes;
class ByteStream;
class Iterator;
 
namespace physical {
class Linear;
} //physical namespace
 
namespace type {
 
template < typename T >
struct IsMemcpySafeImplementation
{
    //@formatter:off
    #if BIO_CPP_VERSION < 11
        // LANDMINE (cpp98): this is UNCONDITIONALLY true — there is no trait-based
        // triviality detection pre-cpp11, so EVERY type reports memcpy-safe here,
        // including non-trivial heap owners (anything with a CowPtr / String /
        // owning member). Arrangement< T > then selects its memcpy specialization
        // on the cpp98 build and byte-copies T WITHOUT running its copy ctor/dtor
        // → refcount is not bumped on copy and the dtor never runs → double-free /
        // premature delete / leak. The SAME source is silently correct on cpp20
        // (where the trait below excludes non-trivial T) and silently corrupting
        // here. Therefore: any by-value Arrangement< NonTrivialT > MUST add an
        // explicit IsMemcpySafeImplementation< T > { sValue = false; } opt-out
        // (see the String/Bytes/ByteStream/Iterator/Linear specializations below).
        static const bool sValue = true;
    #else
        static const bool sValue = IsPrimitive< T >() || IsPointer< T >();
    #endif
    //@formatter:on
};
 
template < typename T >
struct IsMemcpySafeImplementation< T* >
{
    static const bool sValue = true;
};
 
template < typename T >
BIO_CONSTEXPR bool IsMemcpySafe()
{
    return IsMemcpySafeImplementation< T >::sValue;
}
 
template <>
struct IsMemcpySafeImplementation< ::bio::String >
{
    // String owns heap memory; memcpy duplicates pointers and will double-free.
    static const bool sValue = false;
};
 
template <>
struct IsMemcpySafeImplementation< ::bio::Bytes >
{
    // Bytes owns heap memory; memcpy duplicates internal pointers and will double-free.
    static const bool sValue = false;
};
 
template <>
struct IsMemcpySafeImplementation< ::bio::ByteStream >
{
    // ByteStream manages heap memory + type metadata; memcpy would corrupt ownership.
    static const bool sValue = false;
};
 
template <>
struct IsMemcpySafeImplementation< ::bio::Iterator >
{
    // Iterator has internal state; memcpy is undefined.
    static const bool sValue = false;
};
 
template <>
struct IsMemcpySafeImplementation< ::bio::physical::Linear >
{
    // Linear manages ownership; memcpy can corrupt and double-free.
    static const bool sValue = false;
};
 
} //type namespace
} //bio namespace