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_COMPONENT_H
#define VCL_MESH_COMPONENTS_BASE_COMPONENT_H
 
#include "base.h"
 
#include "../concepts/component.h"
#include "../detail/component_data.h"
 
namespace vcl::comp {
 
 
template<
    typename DerivedComponent,   // CRTP pattern, derived class
    uint COMP_ID,                // component id
    typename DataType,           // data stored by the component
    typename ParentElemType,     // parent element type
    bool VERT,                   // true if component vertical
    bool OPT,                    // true if component vertical and optional
    typename... ReferencedTypes> // types of the refs stored by the component
class Component : public ReferencesComponentTriggerer<ReferencedTypes>...
{
public:
    using DataValueType = DataType;
 
    static const bool IS_VERTICAL =
        !std::is_same_v<ParentElemType, void> && VERT;
 
    static const uint COMPONENT_ID = COMP_ID;
 
    static const bool IS_OPTIONAL = VERT && OPT;
 
private:
    detail::ComponentData<DataValueType, IS_VERTICAL> mData;
 
public:
    bool isAvailable() const
    {
        return mData.template isComponentAvailable<ParentElemType>(
            static_cast<const DerivedComponent*>(this));
    }
 
protected:
    DataValueType& data()
    {
        return mData.template get<ParentElemType>(
            static_cast<DerivedComponent*>(this));
    }
 
    const DataValueType& data() const
    {
        return mData.template get<ParentElemType>(
            static_cast<const DerivedComponent*>(this));
    }
 
    ParentElemType* parentElement()
    {
        static_assert(
            !std::is_same_v<ParentElemType, void>,
            "The component should know its parent element type to get access "
            "to its pointer. You should define the component by passing the "
            "element type as template parameter. E.G., for a Face element:\n"
            "vcl::face::TriangleVertexPtrs<Vertex<Scalar>, Face<Scalar>>\n"
            "                                              ^^^^^^^^^^^^ \n");
 
        return static_cast<ParentElemType*>(this);
    }
 
    const ParentElemType* parentElement() const
    {
        static_assert(
            !std::is_same_v<ParentElemType, void>,
            "The component should know its parent element type to get access "
            "to its pointer. You should define the component by passing the "
            "element type as template parameter. E.G., for a Face element:\n"
            "vcl::face::TriangleVertexPtrs<Vertex<Scalar>, Face<Scalar>>\n"
            "                                              ^^^^^^^^^^^^ \n");
 
        return static_cast<const ParentElemType*>(this);
    }
};
 
template<uint COMPONENT_ID, typename T>
bool isComponentAvailableOn(const T& obj)
{
    if constexpr (HasOptionalComponentOfType<T, COMPONENT_ID>) {
        using ComponentType =
            ComponentOfType<COMPONENT_ID, typename T::Components>;
        const ComponentType& c = static_cast<const ComponentType&>(obj);
        return c.isAvailable();
    }
    else
        return HasComponentOfType<T, COMPONENT_ID>;
}
 
template<typename T>
struct IsComponentPred
{
    static const bool value = ComponentConcept<T>;
};
 
template<typename T>
struct IsVerticalComponentPred
{
    static const bool value = IsVerticalComponent<T>;
};
 
 
} // namespace vcl::comp
 
#endif // VCL_MESH_COMPONENTS_BASE_COMPONENT_H