life_cycle.h

Go to the documentation of this file.

/*
 *  Copyright (c) 2000-2022 Inria
 *  All rights reserved.
 *
 *  Redistribution and use in source and binary forms, with or without
 *  modification, are permitted provided that the following conditions are met:
 *
 *  * Redistributions of source code must retain the above copyright notice,
 *  this list of conditions and the following disclaimer.
 *  * Redistributions in binary form must reproduce the above copyright notice,
 *  this list of conditions and the following disclaimer in the documentation
 *  and/or other materials provided with the distribution.
 *  * Neither the name of the ALICE Project-Team nor the names of its
 *  contributors may be used to endorse or promote products derived from this
 *  software without specific prior written permission.
 *
 *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 *  AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 *  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 *  ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
 *  LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 *  CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 *  SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 *  INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 *  CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 *  ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 *  POSSIBILITY OF SUCH DAMAGE.
 *
 *  Contact: Bruno Levy
 *
 *     https://www.inria.fr/fr/bruno-levy
 *
 *     Inria,
 *     Domaine de Voluceau,
 *     78150 Le Chesnay - Rocquencourt
 *     FRANCE
 *
 */
 
#ifndef GEOGRAM_BASIC_LIFE_CYCLE
#define GEOGRAM_BASIC_LIFE_CYCLE
 
#include <geogram/basic/common.h>
#include <geogram/basic/memory.h>
#include <geogram/basic/counted.h>
 
#ifdef GEO_COMPILER_CLANG
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wcast-align"
#endif
 
namespace GEO {
 
    class GEOGRAM_API LifeCycle : public Counted {
      public:
 
        LifeCycle(size_t object_size, bool is_pod=false) :
           object_size_(object_size), is_pod_(is_pod) {
        }
 
        ~LifeCycle() override;
 
        size_t object_size() const {
            return object_size_;
        }
 
        bool is_pod() const {
            return is_pod_;
        }
 
        virtual void construct(Memory::pointer address) = 0;
 
        virtual void copy_construct(
            Memory::pointer lhs, Memory::pointer rhs
        ) = 0;
 
        virtual void destroy(Memory::pointer address) = 0;
 
        virtual void assign(Memory::pointer lhs, Memory::pointer rhs) = 0;
 
        virtual void reset(Memory::pointer address) = 0;
 
 
        virtual void swap(Memory::pointer a, Memory::pointer b) = 0;
 
        virtual void construct_array(Memory::pointer address, index_t nb) = 0;
 
        virtual void copy_construct_array(
            Memory::pointer lhs, Memory::pointer rhs, index_t nb
        ) = 0;
 
        virtual void destroy_array(Memory::pointer address, index_t nb) = 0;
 
        virtual void assign_array(
            Memory::pointer lhs, Memory::pointer rhs, index_t nb
        ) = 0;
 
 
        virtual void reset_array(Memory::pointer address, index_t nb) = 0;
 
        virtual Memory::pointer new_object() = 0;
 
        virtual Memory::pointer new_object(Memory::pointer rhs) = 0;
 
        virtual void delete_object(Memory::pointer address) = 0;
 
        virtual Memory::pointer new_array(index_t nb) = 0;
 
        virtual void delete_array(Memory::pointer address) = 0;
 
 
      private:
        size_t object_size_;
        bool is_pod_;
    };
 
    typedef SmartPointer<LifeCycle> LifeCycle_var;
 
    /*************************************************************************/
 
    template <class T> class GenericLifeCycle : public LifeCycle {
      public:
 
        GenericLifeCycle() : LifeCycle(sizeof(T), std::is_pod<T>::value) {
        }
 
        void construct(Memory::pointer address) override {
            new(address)T;
        }
 
        void copy_construct(Memory::pointer lhs, Memory::pointer rhs) override {
            new(lhs)T(*(T*)rhs);
        }
 
        void destroy(Memory::pointer address) override {
            geo_argused(address); // Silences a MSVC warning.
            ((T*)address)->~T();
        }
 
        void assign(Memory::pointer lhs, Memory::pointer rhs) override {
            *(T*)lhs=*(T*)rhs;
        }
 
        void reset(Memory::pointer address) override {
            *(T*)address = T();
        }
        void swap(Memory::pointer a, Memory::pointer b) override {
            std::swap(*(T*)a, *(T*)b);
        }
 
        void construct_array(Memory::pointer address, index_t nb) override {
            T* array = (T*)address;
            for(index_t i=0; i<nb; ++i) {
                new(&array[i])T;
            }
        }
 
        void copy_construct_array(
            Memory::pointer lhs, Memory::pointer rhs, index_t nb
        ) override {
            T* lhs_array = (T*)lhs;
            T* rhs_array = (T*)rhs;
            for(index_t i=0; i<nb; ++i) {
                new(&lhs_array[i])T(rhs_array[i]);
            }
        }
 
        void destroy_array(Memory::pointer address, index_t nb) override {
            T* array = (T*)address;
            geo_argused(array); // Silences a MSVC warning.
            for(index_t i=0; i<nb; ++i) {
                array[i].~T();
            }
        }
 
        void assign_array(
            Memory::pointer lhs, Memory::pointer rhs, index_t nb
        ) override {
            T* lhs_array = (T*)lhs;
            T* rhs_array = (T*)rhs;
            for(index_t i=0; i<nb; ++i) {
                lhs_array[i] = rhs_array[i];
            }
        }
 
        void reset_array(Memory::pointer address, index_t nb) override {
            T* array = (T*)address;
            geo_argused(array); // Silences a MSVC warning.
            for(index_t i=0; i<nb; ++i) {
                array[i] = T();
            }
        }
 
        Memory::pointer new_object() override {
            return Memory::pointer(new T);
        }
 
        Memory::pointer new_object(Memory::pointer rhs) override {
            return Memory::pointer(new T(*(T*)rhs));
        }
 
        void delete_object(Memory::pointer address) override {
            delete((T*)address);
        }
 
        Memory::pointer new_array(index_t nb) override {
            return Memory::pointer(new T[nb]);
        }
 
        void delete_array(Memory::pointer address) override {
            delete[]((T*)address);
        }
 
    };
 
}
 
#ifdef GEO_COMPILER_CLANG
#pragma GCC diagnostic pop
#endif
 
#endif