named.H

Go to the documentation of this file.

/* Copyright 2022-2026 The Regents of the University of California, through Lawrence
 *           Berkeley National Laboratory (subject to receipt of any required
 *           approvals from the U.S. Dept. of Energy). All rights reserved.
 *
 * This file is part of ImpactX.
 *
 * Authors: Axel Huebl
 * License: BSD-3-Clause-LBNL
 */
#ifndef IMPACTX_ELEMENTS_MIXIN_NAMED_H
#define IMPACTX_ELEMENTS_MIXIN_NAMED_H
 
#include "particles/ImpactXParticleContainer.H"
 
#include <AMReX_Extension.H>
#include <AMReX_GpuQualifiers.H>
 
#include <cstring>
#include <optional>
#include <stdexcept>
#include <string>
 
 
namespace impactx::elements::mixin
{
    struct Named
    {
        static constexpr std::nullopt_t DEFAULT_name = std::nullopt;

        AMREX_GPU_HOST
        void set_name (
            std::string const & new_name
        )
        {
            // free old name
            if (m_name != nullptr) {
                delete[] m_name;
                m_name = nullptr;
            }
 
            // set new name
            if (new_name.size() > 0) {
                m_name = new char[new_name.size() + 1];
                std::strcpy(m_name, new_name.c_str());
            }
        }

        AMREX_GPU_HOST
        Named (
            std::optional<std::string> name
        )
        {
            if (name.has_value()) {
                set_name(*name);
            }
        }
 
        AMREX_GPU_HOST_DEVICE
        ~Named ()
        {
            AMREX_IF_ON_HOST((
                if (m_name != nullptr) {
                    delete[] m_name;
                    m_name = nullptr;
                }
            ))
        }
 
        AMREX_GPU_HOST
        Named (Named const & other)
        {
            if (other.has_name()) {
                m_name = new char[std::strlen(other.m_name) + 1];
                std::strcpy(m_name, other.m_name);
            }
        }
 
        AMREX_GPU_HOST
        Named& operator=(Named const & other)
        {
            if (&other != this) {
                if (other.has_name()) {
                    m_name = new char[std::strlen(other.m_name) + 1];
                    std::strcpy(m_name, other.m_name);
                }
            }
            return *this;
        }
 
        AMREX_GPU_HOST_DEVICE
        Named ([[maybe_unused]] Named && other) noexcept
        {
            AMREX_IF_ON_HOST((
                std::swap(this->m_name, other.m_name);
                other.m_name = nullptr;
            ))
        }
 
        AMREX_GPU_HOST_DEVICE
        Named& operator=([[maybe_unused]] Named && other) noexcept
        {
            AMREX_IF_ON_HOST((
                std::swap(this->m_name, other.m_name);
                other.m_name = nullptr;
            ))
            return *this;
        }

        AMREX_FORCE_INLINE
        std::string name () const
        {
            if (!has_name()) {
                throw std::runtime_error("Name not set on element!");
            }
            return std::string(m_name);
        }

        AMREX_FORCE_INLINE
        bool has_name () const
        {
            return m_name != nullptr;
        }
 
    private:
        // Implementation note:
        // This is used as a mixin class in elements that are copied to GPU. GPU compilers copy
        // a whole element by its sizeof(T).
        // To save on this copy operation at kernel start, this is implemented
        // as a simple C pointer (8 bytes), contrary to a std::string (32 bytes) or
        // a std::optional<std::string> (40 bytes). m_name points to host-side memory and
        // must not be dereferenced (used) on GPU.
        char * m_name = nullptr; 
    };
 
} // namespace impactx::elements::mixin
 
#endif // IMPACTX_ELEMENTS_MIXIN_NAMED_H