class.h

Go to the documentation of this file.

/* SPDX-License-Identifier: LGPL-2.1-or-later */
/*
 * Copyright (C) 2020, Google Inc.
 *
 * Utilities and helpers for classes
 */

#pragma once

#include <memory>

namespace libcamera {

#ifndef __DOXYGEN__
#define LIBCAMERA_DISABLE_COPY(klass)  \
    klass(const klass &) = delete; \
    klass &operator=(const klass &) = delete;

#define LIBCAMERA_DISABLE_MOVE(klass) \
    klass(klass &&) = delete;     \
    klass &operator=(klass &&) = delete;

#define LIBCAMERA_DISABLE_COPY_AND_MOVE(klass) \
    LIBCAMERA_DISABLE_COPY(klass)          \
    LIBCAMERA_DISABLE_MOVE(klass)
#else
#define LIBCAMERA_DISABLE_COPY(klass)
#define LIBCAMERA_DISABLE_MOVE(klass)
#define LIBCAMERA_DISABLE_COPY_AND_MOVE(klass)
#endif

#ifndef __DOXYGEN__
#define LIBCAMERA_DECLARE_PRIVATE()                 \
public:                                 \
    class Private;                          \
    friend class Private;                       \
    template <bool B = true>                    \
    const Private *_d() const                   \
    {                               \
        return Extensible::_d<Private>();           \
    }                               \
    template <bool B = true>                    \
    Private *_d()                           \
    {                               \
        return Extensible::_d<Private>();           \
    }

#define LIBCAMERA_DECLARE_PUBLIC(klass)                 \
    friend class klass;                     \
    using Public = klass;

#define LIBCAMERA_O_PTR()                       \
    _o<Public>()

#else
#define LIBCAMERA_DECLARE_PRIVATE()
#define LIBCAMERA_DECLARE_PUBLIC(klass)
#define LIBCAMERA_O_PTR()
#endif

class Extensible
{
public:
    class Private
    {
    public:
        Private();
        virtual ~Private();

#ifndef __DOXYGEN__
        template<typename T>
        const T *_o() const
        {
            return static_cast<const T *>(o_);
        }

        template<typename T>
        T *_o()
        {
            return static_cast<T *>(o_);
        }
#endif

    private:
        /* To initialize o_ from Extensible. */
        friend class Extensible;
        Extensible *const o_;
    };

    Extensible(std::unique_ptr<Private> d);

protected:
    template<typename T>
    const T *_d() const
    {
        return static_cast<const T *>(d_.get());
    }

    template<typename T>
    T *_d()
    {
        return static_cast<T *>(d_.get());
    }

private:
    const std::unique_ptr<Private> d_;
};

} /* namespace libcamera */