chemical/common/Cast.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) 2022 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/type/IsPointer.h"
#include "bio/common/type/RemovePointer.h"
#include "bio/common/wrapper/Pointer.h"
 
namespace bio {
 
namespace physical {
class Wave;
}
 
namespace chemical_cast_detail {
 
template < typename TO, bool IS_POINTER >
struct CastFromAtom
{
    template < typename ATOM >
    static TO Cast(Pointer< ATOM > atom)
    {
        return atom->template As< TO >();
    }
};
 
template < typename TO >
struct CastFromAtom< TO, true >
{
    template < typename ATOM >
    static TO Cast(Pointer< ATOM > atom)
    {
        typedef typename type::RemovePointer< TO >::Type Pointee;
        Pointer< Pointee > wrapped = atom->template As< Pointee >();
        Pointee* raw = wrapped.Get(); // BIO_RAW_POINTER_ALLOWLIST: cast internals unwrap to the raw address being cast
        return raw;
    }
};
 
} //chemical_cast_detail namespace
 
template < typename TO, typename FROM >
TO ChemicalCast(FROM toCast)
{
    BIO_STATIC_ASSERT(type::IsPointer< FROM >())
    // Null-safe: a NULL input (or a FROM with no Atom) yields NULL, never a
    // deref. ChemicalCast's contract is "the bonded TO or 0", and callers
    // routinely cast results that can legitimately be NULL (e.g. a GetByName
    // miss); without this guard ChemicalCast< X* >(NULL) dereferenced NULL.
    if (!toCast || !toCast->AsAtom())
    {
        return NULL;
    }
    return chemical_cast_detail::CastFromAtom<
        TO,
        type::IsPointerImplementation< TO >::sValue
    >::Cast(toCast->AsAtom());
}
 
template < typename T >
T CloneAndCast(const T& toClone)
{
    //Dereference here might be dangerous & need sanitization.
    ::bio::physical::Wave* clone = toClone->Clone()->AsWave();
    return ChemicalCast< T >(clone);
}
 
 
} //bio namespace