container_component.h

/*****************************************************************************
 * VCLib                                                                     *
 * Visual Computing Library                                                  *
 *                                                                           *
 * Copyright(C) 2021-2025                                                    *
 * Visual Computing Lab                                                      *
 * ISTI - Italian National Research Council                                  *
 *                                                                           *
 * All rights reserved.                                                      *
 *                                                                           *
 * This program is free software; you can redistribute it and/or modify      *
 * it under the terms of the Mozilla Public License Version 2.0 as published *
 * by the Mozilla Foundation; either version 2 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              *
 * Mozilla Public License Version 2.0                                        *
 * (https://www.mozilla.org/en-US/MPL/2.0/) for more details.                *
 ****************************************************************************/
 
#ifndef VCL_MESH_COMPONENTS_BASE_CONTAINER_COMPONENT_H
#define VCL_MESH_COMPONENTS_BASE_CONTAINER_COMPONENT_H
 
#include "component.h"
 
#include <vclib/space/core.h>
 
namespace vcl::comp {
 
namespace detail {
 
// small alias to differentiate between components having only a container or
// components having a container and an additional data type:
// - if AD is void, no additional data and the component will have only a Vector
// - if AD is not void, there is additional data, and the component will have
//   a tuple containing a Vector and the additional data
template<
    typename DC,
    uint CT,
    typename T,
    int N,
    typename AD,
    typename El,
    bool v,
    bool o,
    bool TT,
    typename... PT>
using ContCompBase = std::conditional_t<
    std::is_same_v<AD, void>,
    Component<DC, CT, Vector<T, N>, El, v, o, PT...>,
    Component<DC, CT, std::tuple<Vector<T, N>, AD>, El, v, o, PT...>>;
 
} // namespace detail
 
 
template<
    typename DerivedComponent, // CRTP pattern, derived class
    uint COMP_ID,              // component id
    typename T,                // data stored in container
    int N,                     // container size
    typename AdditionalData,   // additional data outside container
    typename ParentElemType,   // parent element type
    bool VERT,                 // true if component vertical
    bool OPT,                  // true if component vertical and optional
    bool TTVN,                 // true if container size tied to vertex number
    typename... PointedTypes>  // types of pointers stored by the component
class ContainerComponent :
        public detail::ContCompBase<
            DerivedComponent,
            COMP_ID,
            T,
            N,
            AdditionalData,
            ParentElemType,
            VERT,
            OPT,
            TTVN,
            PointedTypes...>
{
    static constexpr bool HAS_ADDITIONAL_DATA =
        !std::is_same_v<AdditionalData, void>;
 
    using Base = detail::ContCompBase<
        DerivedComponent,
        COMP_ID,
        T,
        N,
        AdditionalData,
        ParentElemType,
        VERT,
        OPT,
        TTVN,
        PointedTypes...>;
 
public:
    static const bool TIED_TO_VERTEX_NUMBER = TTVN;
 
    static const int SIZE = N;
 
protected:
    /* Iterator Types declaration */
 
    using Iterator      = Vector<T, N>::Iterator;
    using ConstIterator = Vector<T, N>::ConstIterator;
 
    /* Constructor */
 
    /*
     * Create a container of T objects.
     * If this Container is a static array, all its element will be initialized
     * to T(). If this Container is a dynamic vector, it will be an empty
     * container.
     */
    ContainerComponent()
    {
        if constexpr (!Base::IS_VERTICAL) {
            if constexpr (N >= 0) {
                Base::data().fill(T());
            }
        }
    }
 
    /*
     * Create a container of Objects.
     * If this Container is a static array, all its element will be initialized
     * to T(). If this Container is a dynamic vector, it will be an empty
     * container.
     */
    void init()
    {
        if constexpr (N >= 0) {
            // I'll use the array, N is >= 0.
            // There will be a static number of objects.
            container().fill(T());
        }
        else {
            // I'll use the vector, because N is < 0.
            // There will be a dynamic number of objects.
            container().clear();
        }
    }
 
    Vector<T, N>& container()
    {
        if constexpr (HAS_ADDITIONAL_DATA) {
            return std::get<0>(Base::data());
        }
        else {
            return Base::data();
        }
    }
 
    const Vector<T, N>& container() const
    {
        if constexpr (HAS_ADDITIONAL_DATA) {
            return std::get<0>(Base::data());
        }
        else {
            return Base::data();
        }
    }
 
    template<typename AdDt = AdditionalData>
    AdDt& additionalData() requires (HAS_ADDITIONAL_DATA)
    {
        return std::get<1>(Base::data());
    }
 
    template<typename AdDt = AdditionalData>
    const AdDt& additionalData() const requires (HAS_ADDITIONAL_DATA)
    {
        return std::get<1>(Base::data());
    }
};
 
 
} // namespace vcl::comp
 
#endif // VCL_MESH_COMPONENTS_BASE_CONTAINER_COMPONENT_H