GeoPropertyGuard.h

Go to the documentation of this file.

//-
//*****************************************************************************
// Copyright 2025 Autodesk, Inc.
// All rights reserved.
//
// These coded instructions, statements, and computer programs contain
// unpublished proprietary information written by Autodesk, Inc. and are
// protected by Federal copyright law. They may not be disclosed to third
// parties or copied or duplicated in any form, in whole or in part, without
// the prior written consent of Autodesk, Inc.
//*****************************************************************************
//+
 
 
#ifndef BIFROST_GEOMETRY_GEO_PROPERTY_GUARD_H
#define BIFROST_GEOMETRY_GEO_PROPERTY_GUARD_H
 
#include <Bifrost/Geometry/GeometryExport.h>
 
#include <Bifrost/Geometry/GeoProperty.h> // DataInterpolationMode
#include <Bifrost/Math/Types.h>
#include <Bifrost/Object/Object.h>
 
#include <Amino/Core/Array.h>
#include <Amino/Core/Ptr.h>
#include <Amino/Core/StringView.h>
 
namespace Bifrost {
 
template <typename T>
class PropertyGuard;
 
template <typename T>
bool hasProperty(const Bifrost::Object& object, Amino::StringView propertyName);
 
template <typename T>
PropertyGuard<T> createPropGuard(Bifrost::Object& object, Amino::StringView propertyName);
 
template <typename T>
PropertyGuard<Amino::Ptr<T>> createPtrPropGuard(Bifrost::Object&  object,
                                                Amino::StringView propertyName);
 
} // namespace Bifrost
 
namespace Bifrost {
namespace Geometry {
 
template <typename T>
class DataGeoPropertyGuard;
 
class RangeGeoPropertyGuard;
 
template <typename T>
bool hasDataGeoProperty(const Bifrost::Object& geometry, Amino::StringView property);
 
template <typename T>
DataGeoPropertyGuard<T> createDataGeoPropGuard(Bifrost::Object&  geometry,
                                               Amino::StringView propertyName);
 
BIFROST_GEOMETRY_DECL
bool hasRangeGeoProperty(const Bifrost::Object& geometry, Amino::StringView property);
 
BIFROST_GEOMETRY_DECL
RangeGeoPropertyGuard createRangeGeoPropGuard(Bifrost::Object&  geometry,
                                              Amino::StringView propertyName);
 
} // namespace Geometry
} // namespace Bifrost
 
// Implementation:
 
namespace Bifrost {
 
template <typename T>
bool hasProperty(const Bifrost::Object& object, Amino::StringView propertyName) {
    auto any = object.getProperty(propertyName);
    return any.type() == Amino::Any{T{}}.type();
}
 
template <typename T>
PropertyGuard<T> createPropGuard(Bifrost::Object& object, Amino::StringView propertyName) {
    return hasProperty<T>(object, propertyName)
               ? PropertyGuard<T>(object, Amino::String(propertyName))
               : PropertyGuard<T>{};
}
 
template <typename T>
PropertyGuard<Amino::Ptr<T>> createPtrPropGuard(Bifrost::Object&  object,
                                                Amino::StringView propertyName) {
    return createPropGuard<Amino::Ptr<T>>(object, propertyName);
}
 
// -----------------------------------------------------------------------------
template <typename T>
class PropertyGuard {
public:
    PropertyGuard() = default;
 
    ~PropertyGuard() {
        if (m_object != nullptr) {
            m_object->setProperty(m_propertyName, std::move(m_property));
        }
    }
 
    PropertyGuard(const PropertyGuard&) = delete;
    PropertyGuard& operator=(const PropertyGuard&) = delete;
 
    PropertyGuard(PropertyGuard&& io) noexcept
    : m_object(std::exchange(io.m_object, nullptr))
    , m_propertyName(std::move(io.m_propertyName))
    , m_property(std::move(io.m_property))
    {
    }
 
    PropertyGuard& operator=(PropertyGuard&& io) noexcept
    {
        if (this != &io) {
            m_object = std::exchange(io.m_object, nullptr);
            m_propertyName = std::move(io.m_propertyName);
            m_property = std::move(io.m_property);
        }
        return *this;
    }
 
    explicit operator bool() const noexcept { return m_object != nullptr; }
 
    const T& operator*() const noexcept {
        assert(m_object != nullptr);
        return m_property;
    }
 
    T& operator*() noexcept {
        assert(m_object != nullptr);
        return m_property;
    }
 
    const T* operator->() const noexcept {
        assert(m_object != nullptr);
        return &m_property;
    }
 
    T* operator->() noexcept {
        assert(m_object != nullptr);
        return &m_property;
    }
 
private:
    friend PropertyGuard<T> createPropGuard<T>(Bifrost::Object&, Amino::StringView);
 
    PropertyGuard(Bifrost::Object& object, Amino::String propertyName)
        : m_object(&object), m_propertyName(std::move(propertyName)) {
        auto any = m_object->extractProperty(m_propertyName);
        m_property = Amino::any_cast<T>(std::move(any));
    }
 
    Bifrost::Object* m_object = nullptr;
    Amino::String m_propertyName;
    T m_property;
};
 
template <typename T>
class PropertyGuard<Amino::Ptr<T>> {
public:
    PropertyGuard() = default;
 
    ~PropertyGuard() {
        if (m_object != nullptr) {
            m_object->setProperty(m_propertyName, std::move(m_property));
        }
    }
 
    PropertyGuard(const PropertyGuard&) = delete;
    PropertyGuard& operator=(const PropertyGuard&) = delete;
 
    PropertyGuard(PropertyGuard&& io) noexcept
    : m_object(std::exchange(io.m_object, nullptr))
    , m_propertyName(std::move(io.m_propertyName))
    , m_property(std::move(io.m_property))
    {
    }
 
    PropertyGuard& operator=(PropertyGuard&& io) noexcept
    {
        if (this != &io) {
            m_object = std::exchange(io.m_object, nullptr);
            m_propertyName = std::move(io.m_propertyName);
            m_property = std::move(io.m_property);
        }
        return *this;
    }
 
    explicit operator bool() const noexcept { return m_object != nullptr; }
 
    const T& operator*() const noexcept {
        assert(m_object != nullptr);
        return *m_property;
    }
 
    T& operator*() noexcept {
        assert(m_object != nullptr);
        return *m_property;
    }
 
    const T* operator->() const noexcept {
        assert(m_object != nullptr);
        return m_property.get();
    }
 
    T* operator->() noexcept {
        assert(m_object != nullptr);
        return m_property.get();
    }
 
private:
    friend PropertyGuard<Amino::Ptr<T>> createPropGuard<Amino::Ptr<T>>(Bifrost::Object&,
                                                                       Amino::StringView);
    friend PropertyGuard<Amino::Ptr<T>> createPtrPropGuard<T>(Bifrost::Object&, Amino::StringView);
 
    PropertyGuard(Bifrost::Object& object, Amino::String propertyName)
        : m_object(&object), m_propertyName(std::move(propertyName)) {
        auto any = m_object->extractProperty(m_propertyName);
        auto constProp = Amino::any_cast<Amino::Ptr<T>>(std::move(any));
        m_property = constProp.toMutable();
    }
 
    Bifrost::Object* m_object = nullptr;
    Amino::String m_propertyName;
    Amino::MutablePtr<T> m_property;
};
 
} // namespace Bifrost
 
namespace Bifrost {
namespace Geometry {
 
// -----------------------------------------------------------------------------
template <typename T>
bool hasDataGeoProperty(const Bifrost::Object& geometry, Amino::StringView property) {
    // Check if the property exists and matches the Data geo property schema
    auto propObj = Bifrost::Geometry::getDataGeoProperty(geometry, property);
    if (!propObj) return false;
 
    // Check the data type matches
    auto dataArray = Bifrost::Geometry::getDataGeoPropValues<T>(geometry, property);
    return dataArray != nullptr;
}
 
// -----------------------------------------------------------------------------
template <typename T>
class DataGeoPropertyGuard
{
public:
    DataGeoPropertyGuard() = default;
 
    explicit operator bool() const noexcept { return static_cast<bool>(m_property); }
 
    const Amino::Array<T>& data() const noexcept { return *m_data; }
 
    Amino::Array<T>& data() noexcept { return *m_data; }
 
    const Amino::String& target() const noexcept { return *m_target; }
 
    Amino::String& target() noexcept { return *m_target; }
 
    const Amino::Array<Amino::String>& dependsOn() const noexcept { return *m_dependsOn; }
 
    Amino::Array<Amino::String>& dependsOn() noexcept { return *m_dependsOn; }
 
    const T& defaultValue() const noexcept { return *m_defaultValue; }
 
    T& defaultValue() noexcept { return *m_defaultValue; }
 
    const Bifrost::Geometry::Common::DataInterpolationMode& interpolationMode() const noexcept {
        return *m_interp;
    }
 
    Bifrost::Geometry::Common::DataInterpolationMode& interpolationMode() noexcept {
        return *m_interp;
    }
 
private:
    friend DataGeoPropertyGuard<T> createDataGeoPropGuard<T>(Bifrost::Object&, Amino::StringView);
 
    DataGeoPropertyGuard(Bifrost::Object& object, Amino::StringView propertyName)
        : m_property(createPtrPropGuard<Bifrost::Object>(object, propertyName)),
          m_data(createPtrPropGuard<Amino::Array<T>>(*m_property, Bifrost::Geometry::sData)),
          m_target(createPropGuard<Amino::String>(*m_property, Bifrost::Geometry::sTarget)),
          m_dependsOn(createPtrPropGuard<Amino::Array<Amino::String>>(
              *m_property, Bifrost::Geometry::sDependsOn)),
          m_defaultValue(createPropGuard<T>(*m_property, Bifrost::Geometry::sDefault)),
          m_interp(createPropGuard<Bifrost::Geometry::Common::DataInterpolationMode>(
              *m_property, Bifrost::Geometry::sInterp)) {}
 
    PropertyGuard<Amino::Ptr<Bifrost::Object>> m_property;
    PropertyGuard<Amino::Ptr<Amino::Array<T>>> m_data;
    PropertyGuard<Amino::String> m_target;
    PropertyGuard<Amino::Ptr<Amino::Array<Amino::String>>> m_dependsOn;
    PropertyGuard<T> m_defaultValue;
    PropertyGuard<Bifrost::Geometry::Common::DataInterpolationMode> m_interp;
};
 
// -----------------------------------------------------------------------------
template <typename T>
DataGeoPropertyGuard<T> createDataGeoPropGuard(Bifrost::Object&  geometry,
                                               Amino::StringView propertyName) {
    return hasDataGeoProperty<T>(geometry, propertyName)
               ? DataGeoPropertyGuard<T>(geometry, propertyName)
               : DataGeoPropertyGuard<T>{};
}
 
// -----------------------------------------------------------------------------
class RangeGeoPropertyGuard {
public:
    RangeGeoPropertyGuard() = default;
 
    explicit operator bool() const noexcept { return static_cast<bool>(m_property); }
 
    const Amino::Array<Bifrost::Geometry::Index>& indices() const noexcept { return *m_indices; }
 
    Amino::Array<Bifrost::Geometry::Index>& indices() noexcept { return *m_indices; }
 
    const Amino::String& target() const noexcept { return *m_target; }
 
    Amino::String& target() noexcept { return *m_target; }
 
    const Amino::Array<Amino::String>& dependsOn() const noexcept { return *m_dependsOn; }
 
    Amino::Array<Amino::String>& dependsOn() noexcept { return *m_dependsOn; }
 
private:
    friend BIFROST_GEOMETRY_DECL RangeGeoPropertyGuard createRangeGeoPropGuard(Bifrost::Object&,
                                                                               Amino::StringView);
 
    RangeGeoPropertyGuard(Bifrost::Object& object, Amino::StringView propertyName)
        : m_property(createPtrPropGuard<Bifrost::Object>(object, propertyName)),
          m_indices(createPtrPropGuard<Amino::Array<Bifrost::Geometry::Index>>(
              *m_property, Bifrost::Geometry::sIndices)),
          m_target(createPropGuard<Amino::String>(*m_property, Bifrost::Geometry::sTarget)),
          m_dependsOn(createPtrPropGuard<Amino::Array<Amino::String>>(
              *m_property, Bifrost::Geometry::sDependsOn)) {}
 
    PropertyGuard<Amino::Ptr<Bifrost::Object>>                        m_property;
    PropertyGuard<Amino::Ptr<Amino::Array<Bifrost::Geometry::Index>>> m_indices;
    PropertyGuard<Amino::String>                                      m_target;
    PropertyGuard<Amino::Ptr<Amino::Array<Amino::String>>>            m_dependsOn;
};
 
} // namespace Geometry
} // namespace Bifrost
 
#endif // BIFROST_GEOMETRY_GEO_PROPERTY_GUARD_H