TransparentWrapper.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) 2023 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 <ostream>
#include "bio/common/type/IsPointer.h"
 
namespace bio {
 
//@formatter:off
 
template < typename T >
class TransparentWrapper
{
public:
    typedef T Type;
 
    TransparentWrapper(T t) : mT(t) {}
    TransparentWrapper(const TransparentWrapper<T>& other) : mT(other.mT) {}
    // NON-virtual since v12 (no vtable / no vptr). Never delete a subclass through
    // a TransparentWrapper< T >* base pointer — see the class doc above.
    ~TransparentWrapper()
    {
        #if BIO_CPP_VERSION >= 17
        if BIO_CONSTEXPR(type::IsPointer<T>())
        {
            delete mT;
        }
        #endif
        //FIXME: memory leaks when wrapping pointers on cpp < 17
    }
    operator T() {return mT;}
//  explicit operator const T() const {return mT;} // Breaks everything....
 
    //START: Support for basic types
    //TODO: Add pointer support for basic methods
    TransparentWrapper<T>& operator=(const T& t) {mT = t; return *this;}
    TransparentWrapper<T>& operator=(const TransparentWrapper<T>& other) {mT = other.mT; return *this;}
    bool operator==(const T& t) const  {return mT == t;}
    bool operator!=(const T& t) const  {return mT != t;}
    bool operator<=(const T& t) const  {return mT <= t;}
    bool operator>=(const T& t) const  {return mT >= t;}
    bool operator<(const T& t) const {return mT < t;}
    bool operator>(const T& t) const {return mT > t;}
    bool operator==(const TransparentWrapper& other) const {return mT == other.mT;}
    bool operator!=(const TransparentWrapper& other) const {return mT != other.mT;}
    bool operator<=(const TransparentWrapper& other) const {return mT <= other.mT;}
    bool operator>=(const TransparentWrapper& other) const {return mT >= other.mT;}
    bool operator<(const TransparentWrapper& other) const {return mT < other.mT;}
    bool operator>(const TransparentWrapper& other) const {return mT > other.mT;}
    T& operator++() {return ++mT;}
    T operator++(int) {return mT++;}
    T& operator--() {return --mT;}
    T operator--(int) {return mT--;}
    T operator+=(const T& t) {return mT += t;}
    T operator-=(const T& t) {return mT -= t;}
    T operator+=(const TransparentWrapper& other) {return mT += other.mT;}
    T operator-=(const TransparentWrapper& other) {return mT -= other.mT;}
    T operator+(const T& t) const {return mT + t;}
    T operator-(const T& t) const {return mT - t;}
    T operator+(const TransparentWrapper& other) const {return mT + other.mT;}
    T operator-(const TransparentWrapper& other) const {return mT - other.mT;}
    T operator*=(const T& t) {return mT *= t;}
    T operator/=(const T& t) {return mT /= t;}
    T operator*=(const TransparentWrapper& other) {return mT *= other.mT;}
    T operator/=(const TransparentWrapper& other) {return mT /= other.mT;}
    T operator*(const T& t) const {return mT * t;}
    T operator/(const T& t) const {return mT / t;}
    T operator*(const TransparentWrapper& other) const {return mT * other.mT;}
    T operator/(const TransparentWrapper& other) const {return mT / other.mT;}
    friend ::std::ostream& operator <<(std::ostream& out, const TransparentWrapper& t)
    {
        out << t.mT;
        return out;
    }
    //END: Support for basic types
 
    //START: Support for pointers
    T* operator->() {
        if BIO_CONSTEXPR(type::IsPointer<T>())
        {
            return mT;
        }
        return &mT;
    }
    const T* operator->() const
    {
        if BIO_CONSTEXPR(type::IsPointer<T>())
        {
            return mT;
        }
        return &mT;
    }
    //END: Support for pointers
 
    //that's all we're doing for now. Please add to this list as necessary
 
    //public because we need to treat this as T when we don't know the T.
public:
    T mT;
};
//@formatter:on
 
} //bio namespace