Allow specialisation of vsg::Inherit for sublasses, alternative implementation.

AnyOldName3 · AnyOldName3 · commit 74f77ca87d36 · 2025-12-03T17:09:49.000Z
Like e07a87f / vsg-dev#1609, but a bit simpler and easier to use
diff --git a/include/vsg/core/Inherit.h b/include/vsg/core/Inherit.h
@@ -20,16 +20,29 @@ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLI
 
 namespace vsg
 {
+    template<class ParentClass, class Subclass, class Enable = void>
+    struct InheritHelper
+    {
+        using Type = ParentClass;
+    };
+
+    template<class ParentClass, class Subclass>
+    struct InheritHelper<ParentClass, Subclass, typename ParentClass::template InheritExtras<ParentClass, Subclass>>
+    {
+        using Type = typename ParentClass::template InheritExtras<ParentClass, Subclass>;
+    };
 
     /// Inherit<> uses the Curiously Recurring Template Pattern
     /// to provide the classes versions of create, accept(..), RTTI and sizeofObject()
     template<class ParentClass, class Subclass>
-    class Inherit : public ParentClass
+    class Inherit : public InheritHelper<ParentClass, Subclass>::Type
     {
     public:
+        using BaseClass = typename InheritHelper<ParentClass, Subclass>::Type;
+
         template<typename... Args>
         Inherit(Args&&... args) :
-            ParentClass(std::forward<Args>(args)...) {}
+            BaseClass(std::forward<Args>(args)...) {}
 
         template<typename... Args>
         static ref_ptr<Subclass> create(Args&&... args)
@@ -47,11 +60,11 @@ namespace vsg
         std::size_t sizeofObject() const noexcept override { return sizeof(Subclass); }
         const char* className() const noexcept override { return type_name<Subclass>(); }
         const std::type_info& type_info() const noexcept override { return typeid(Subclass); }
-        bool is_compatible(const std::type_info& type) const noexcept override { return typeid(Subclass) == type || ParentClass::is_compatible(type); }
+        bool is_compatible(const std::type_info& type) const noexcept override { return typeid(Subclass) == type || BaseClass::is_compatible(type); }
 
         int compare(const Object& rhs) const override
         {
-            int result = ParentClass::compare(rhs);
+            int result = BaseClass::compare(rhs);
             if (result != 0) return result;
 
             size_t startOfSubclass = sizeof(ParentClass);
diff --git a/include/vsg/state/ArrayState.h b/include/vsg/state/ArrayState.h
@@ -27,6 +27,28 @@ namespace vsg
     class VSG_DECLSPEC ArrayState : public Inherit<ConstVisitor, ArrayState>
     {
     public:
+        template<class ParentClass, class Subclass>
+        class InheritExtras : public ParentClass
+        {
+        public:
+            using ParentClass::ParentClass;
+
+            explicit InheritExtras(const ArrayState& rhs, const CopyOp& copyop = {}) :
+                ParentClass(rhs, copyop)
+            {
+            }
+
+            ref_ptr<ArrayState> cloneArrayState() override
+            {
+                return Subclass::create(static_cast<Subclass&>(*this));
+            }
+
+            ref_ptr<ArrayState> cloneArrayState(ref_ptr<ArrayState> arrayState) override
+            {
+                return Subclass::create(static_cast<Subclass&>(*arrayState));
+            }
+        };
+
         ArrayState() = default;
         ArrayState(const ArrayState& rhs, const CopyOp& copyop = {});
 
@@ -106,9 +128,6 @@ namespace vsg
         NullArrayState();
         explicit NullArrayState(const ArrayState& as);
 
-        ref_ptr<ArrayState> cloneArrayState() override;
-        ref_ptr<ArrayState> cloneArrayState(ref_ptr<ArrayState> arrayState) override;
-
         using ArrayState::apply;
 
         void apply(const vec3Array&) override;
@@ -124,9 +143,6 @@ namespace vsg
         TranslationArrayState(const TranslationArrayState& rhs);
         explicit TranslationArrayState(const ArrayState& rhs);
 
-        ref_ptr<ArrayState> cloneArrayState() override;
-        ref_ptr<ArrayState> cloneArrayState(ref_ptr<ArrayState> arrayState) override;
-
         uint32_t translation_attribute_location = 7;
         AttributeDetails translationAttribute;
 
@@ -145,9 +161,6 @@ namespace vsg
         TranslationRotationScaleArrayState(const TranslationRotationScaleArrayState& rhs);
         explicit TranslationRotationScaleArrayState(const ArrayState& rhs);
 
-        ref_ptr<ArrayState> cloneArrayState() override;
-        ref_ptr<ArrayState> cloneArrayState(ref_ptr<ArrayState> arrayState) override;
-
         uint32_t translation_attribute_location = 7;
         uint32_t rotation_attribute_location = 8;
         uint32_t scale_attribute_location = 9;
@@ -168,10 +181,7 @@ namespace vsg
     public:
         DisplacementMapArrayState();
         DisplacementMapArrayState(const DisplacementMapArrayState& rhs);
-        explicit DisplacementMapArrayState(const ArrayState& rhs);
-
-        ref_ptr<ArrayState> cloneArrayState() override;
-        ref_ptr<ArrayState> cloneArrayState(ref_ptr<ArrayState> arrayState) override;
+        explicit DisplacementMapArrayState(const ArrayState& rhs, const CopyOp& copyop = {});
 
         // binding of displacement map
         uint32_t normal_attribute_location = 1;
@@ -207,9 +217,6 @@ namespace vsg
         uint32_t translation_attribute_location = 7;
         AttributeDetails translationAttribute;
 
-        ref_ptr<ArrayState> cloneArrayState() override;
-        ref_ptr<ArrayState> cloneArrayState(ref_ptr<ArrayState> arrayState) override;
-
         void apply(const VertexInputState& vas) override;
         ref_ptr<const vec3Array> vertexArray(uint32_t instanceIndex) override;
     };
@@ -223,9 +230,6 @@ namespace vsg
         BillboardArrayState(const BillboardArrayState& rhs);
         explicit BillboardArrayState(const ArrayState& rhs);
 
-        ref_ptr<ArrayState> cloneArrayState() override;
-        ref_ptr<ArrayState> cloneArrayState(ref_ptr<ArrayState> arrayState) override;
-
         uint32_t translation_attribute_location = 7;
         AttributeDetails translationAttribute;
 
diff --git a/src/vsg/state/ArrayState.cpp b/src/vsg/state/ArrayState.cpp
@@ -219,17 +219,6 @@ NullArrayState::NullArrayState(const ArrayState& as) :
     vertices = {};
 }
 
-ref_ptr<ArrayState> NullArrayState::cloneArrayState()
-{
-    return NullArrayState::create(*this);
-}
-
-// clone the specified ArrayState
-ref_ptr<ArrayState> NullArrayState::cloneArrayState(ref_ptr<ArrayState> arrayState)
-{
-    return NullArrayState::create(*arrayState);
-}
-
 void NullArrayState::apply(const vsg::vec3Array&)
 {
     vertices = {};
@@ -260,16 +249,6 @@ TranslationArrayState::TranslationArrayState(const ArrayState& rhs) :
 {
 }
 
-ref_ptr<ArrayState> TranslationArrayState::cloneArrayState()
-{
-    return TranslationArrayState::create(*this);
-}
-
-ref_ptr<ArrayState> TranslationArrayState::cloneArrayState(ref_ptr<ArrayState> arrayState)
-{
-    return TranslationArrayState::create(*arrayState);
-}
-
 void TranslationArrayState::apply(const VertexInputState& vas)
 {
     getAttributeDetails(vas, vertex_attribute_location, vertexAttribute);
@@ -315,16 +294,6 @@ TranslationRotationScaleArrayState::TranslationRotationScaleArrayState(const Arr
 {
 }
 
-ref_ptr<ArrayState> TranslationRotationScaleArrayState::cloneArrayState()
-{
-    return TranslationRotationScaleArrayState::create(*this);
-}
-
-ref_ptr<ArrayState> TranslationRotationScaleArrayState::cloneArrayState(ref_ptr<ArrayState> arrayState)
-{
-    return TranslationRotationScaleArrayState::create(*arrayState);
-}
-
 void TranslationRotationScaleArrayState::apply(const VertexInputState& vas)
 {
     getAttributeDetails(vas, vertex_attribute_location, vertexAttribute);
@@ -373,21 +342,11 @@ DisplacementMapArrayState::DisplacementMapArrayState(const DisplacementMapArrayS
 {
 }
 
-DisplacementMapArrayState::DisplacementMapArrayState(const ArrayState& rhs) :
-    Inherit(rhs)
+DisplacementMapArrayState::DisplacementMapArrayState(const ArrayState& rhs, const CopyOp& copyop) :
+    Inherit(rhs, copyop)
 {
 }
 
-ref_ptr<ArrayState> DisplacementMapArrayState::cloneArrayState()
-{
-    return DisplacementMapArrayState::create(*this);
-}
-
-ref_ptr<ArrayState> DisplacementMapArrayState::cloneArrayState(ref_ptr<ArrayState> arrayState)
-{
-    return DisplacementMapArrayState::create(*arrayState);
-}
-
 void DisplacementMapArrayState::apply(const DescriptorImage& di)
 {
     if (!di.imageInfoList.empty())
@@ -485,16 +444,6 @@ TranslationAndDisplacementMapArrayState::TranslationAndDisplacementMapArrayState
 {
 }
 
-ref_ptr<ArrayState> TranslationAndDisplacementMapArrayState::cloneArrayState()
-{
-    return TranslationAndDisplacementMapArrayState::create(*this);
-}
-
-ref_ptr<ArrayState> TranslationAndDisplacementMapArrayState::cloneArrayState(ref_ptr<ArrayState> arrayState)
-{
-    return TranslationAndDisplacementMapArrayState::create(*arrayState);
-}
-
 void TranslationAndDisplacementMapArrayState::apply(const VertexInputState& vas)
 {
     getAttributeDetails(vas, vertex_attribute_location, vertexAttribute);
@@ -562,16 +511,6 @@ BillboardArrayState::BillboardArrayState(const ArrayState& rhs) :
 {
 }
 
-ref_ptr<ArrayState> BillboardArrayState::cloneArrayState()
-{
-    return BillboardArrayState::create(*this);
-}
-
-ref_ptr<ArrayState> BillboardArrayState::cloneArrayState(ref_ptr<ArrayState> arrayState)
-{
-    return BillboardArrayState::create(*arrayState);
-}
-
 void BillboardArrayState::apply(const VertexInputState& vas)
 {
     getAttributeDetails(vas, vertex_attribute_location, vertexAttribute);
diff --git a/src/vsg/text/CpuLayoutTechnique.cpp b/src/vsg/text/CpuLayoutTechnique.cpp
@@ -47,10 +47,7 @@ class VSG_DECLSPEC CpuLayoutTechniqueArrayState : public Inherit<ArrayState, Cpu
     {
     }
 
-    ref_ptr<ArrayState> cloneArrayState() override
-    {
-        return CpuLayoutTechniqueArrayState::create(*this);
-    }
+    using Inherit::cloneArrayState;
 
     ref_ptr<ArrayState> cloneArrayState(ref_ptr<ArrayState> arrayState) override
     {
diff --git a/src/vsg/text/GpuLayoutTechnique.cpp b/src/vsg/text/GpuLayoutTechnique.cpp
@@ -51,10 +51,7 @@ class VSG_DECLSPEC GpuLayoutTechniqueArrayState : public Inherit<ArrayState, Gpu
     {
     }
 
-    ref_ptr<ArrayState> cloneArrayState() override
-    {
-        return GpuLayoutTechniqueArrayState::create(*this);
-    }
+    using Inherit::cloneArrayState;
 
     ref_ptr<ArrayState> cloneArrayState(ref_ptr<ArrayState> arrayState) override
     {

Original file line number	Diff line number	Diff line change
`@@ -219,17 +219,6 @@ NullArrayState::NullArrayState(const ArrayState& as) :`
`219`	`219`	`vertices = {};`
`220`	`220`	`}`
`221`	`221`
`222`		`-ref_ptr<ArrayState> NullArrayState::cloneArrayState()`
`223`		`-{`
`224`		`- return NullArrayState::create(*this);`
`225`		`-}`
`226`		`-`
`227`		`-// clone the specified ArrayState`
`228`		`-ref_ptr<ArrayState> NullArrayState::cloneArrayState(ref_ptr<ArrayState> arrayState)`
`229`		`-{`
`230`		`- return NullArrayState::create(*arrayState);`
`231`		`-}`
`232`		`-`
`233`	`222`	`void NullArrayState::apply(const vsg::vec3Array&)`
`234`	`223`	`{`
`235`	`224`	`vertices = {};`
`@@ -260,16 +249,6 @@ TranslationArrayState::TranslationArrayState(const ArrayState& rhs) :`
`260`	`249`	`{`
`261`	`250`	`}`
`262`	`251`
`263`		`-ref_ptr<ArrayState> TranslationArrayState::cloneArrayState()`
`264`		`-{`
`265`		`- return TranslationArrayState::create(*this);`
`266`		`-}`
`267`		`-`
`268`		`-ref_ptr<ArrayState> TranslationArrayState::cloneArrayState(ref_ptr<ArrayState> arrayState)`
`269`		`-{`
`270`		`- return TranslationArrayState::create(*arrayState);`
`271`		`-}`
`272`		`-`
`273`	`252`	`void TranslationArrayState::apply(const VertexInputState& vas)`
`274`	`253`	`{`
`275`	`254`	`getAttributeDetails(vas, vertex_attribute_location, vertexAttribute);`
`@@ -315,16 +294,6 @@ TranslationRotationScaleArrayState::TranslationRotationScaleArrayState(const Arr`
`315`	`294`	`{`
`316`	`295`	`}`
`317`	`296`
`318`		`-ref_ptr<ArrayState> TranslationRotationScaleArrayState::cloneArrayState()`
`319`		`-{`
`320`		`- return TranslationRotationScaleArrayState::create(*this);`
`321`		`-}`
`322`		`-`
`323`		`-ref_ptr<ArrayState> TranslationRotationScaleArrayState::cloneArrayState(ref_ptr<ArrayState> arrayState)`
`324`		`-{`
`325`		`- return TranslationRotationScaleArrayState::create(*arrayState);`
`326`		`-}`
`327`		`-`
`328`	`297`	`void TranslationRotationScaleArrayState::apply(const VertexInputState& vas)`
`329`	`298`	`{`
`330`	`299`	`getAttributeDetails(vas, vertex_attribute_location, vertexAttribute);`
`@@ -373,21 +342,11 @@ DisplacementMapArrayState::DisplacementMapArrayState(const DisplacementMapArrayS`
`373`	`342`	`{`
`374`	`343`	`}`
`375`	`344`
`376`		`-DisplacementMapArrayState::DisplacementMapArrayState(const ArrayState& rhs) :`
`377`		`- Inherit(rhs)`
	`345`	`+DisplacementMapArrayState::DisplacementMapArrayState(const ArrayState& rhs, const CopyOp& copyop) :`
	`346`	`+ Inherit(rhs, copyop)`
`378`	`347`	`{`
`379`	`348`	`}`
`380`	`349`
`381`		`-ref_ptr<ArrayState> DisplacementMapArrayState::cloneArrayState()`
`382`		`-{`
`383`		`- return DisplacementMapArrayState::create(*this);`
`384`		`-}`
`385`		`-`
`386`		`-ref_ptr<ArrayState> DisplacementMapArrayState::cloneArrayState(ref_ptr<ArrayState> arrayState)`
`387`		`-{`
`388`		`- return DisplacementMapArrayState::create(*arrayState);`
`389`		`-}`
`390`		`-`
`391`	`350`	`void DisplacementMapArrayState::apply(const DescriptorImage& di)`
`392`	`351`	`{`
`393`	`352`	`if (!di.imageInfoList.empty())`
`@@ -485,16 +444,6 @@ TranslationAndDisplacementMapArrayState::TranslationAndDisplacementMapArrayState`
`485`	`444`	`{`
`486`	`445`	`}`
`487`	`446`
`488`		`-ref_ptr<ArrayState> TranslationAndDisplacementMapArrayState::cloneArrayState()`
`489`		`-{`
`490`		`- return TranslationAndDisplacementMapArrayState::create(*this);`
`491`		`-}`
`492`		`-`
`493`		`-ref_ptr<ArrayState> TranslationAndDisplacementMapArrayState::cloneArrayState(ref_ptr<ArrayState> arrayState)`
`494`		`-{`
`495`		`- return TranslationAndDisplacementMapArrayState::create(*arrayState);`
`496`		`-}`
`497`		`-`
`498`	`447`	`void TranslationAndDisplacementMapArrayState::apply(const VertexInputState& vas)`
`499`	`448`	`{`
`500`	`449`	`getAttributeDetails(vas, vertex_attribute_location, vertexAttribute);`
`@@ -562,16 +511,6 @@ BillboardArrayState::BillboardArrayState(const ArrayState& rhs) :`
`562`	`511`	`{`
`563`	`512`	`}`
`564`	`513`
`565`		`-ref_ptr<ArrayState> BillboardArrayState::cloneArrayState()`
`566`		`-{`
`567`		`- return BillboardArrayState::create(*this);`
`568`		`-}`
`569`		`-`
`570`		`-ref_ptr<ArrayState> BillboardArrayState::cloneArrayState(ref_ptr<ArrayState> arrayState)`
`571`		`-{`
`572`		`- return BillboardArrayState::create(*arrayState);`
`573`		`-}`
`574`		`-`
`575`	`514`	`void BillboardArrayState::apply(const VertexInputState& vas)`
`576`	`515`	`{`
`577`	`516`	`getAttributeDetails(vas, vertex_attribute_location, vertexAttribute);`
Original file line number	Diff line number	Diff line change
`@@ -47,10 +47,7 @@ class VSG_DECLSPEC CpuLayoutTechniqueArrayState : public Inherit<ArrayState, Cpu`
`47`	`47`	`{`
`48`	`48`	`}`
`49`	`49`
`50`		`- ref_ptr<ArrayState> cloneArrayState() override`
`51`		`- {`
`52`		`- return CpuLayoutTechniqueArrayState::create(*this);`
`53`		`- }`
	`50`	`+ using Inherit::cloneArrayState;`
`54`	`51`
`55`	`52`	`ref_ptr<ArrayState> cloneArrayState(ref_ptr<ArrayState> arrayState) override`
`56`	`53`	`{`
Original file line number	Diff line number	Diff line change
`@@ -51,10 +51,7 @@ class VSG_DECLSPEC GpuLayoutTechniqueArrayState : public Inherit<ArrayState, Gpu`
`51`	`51`	`{`
`52`	`52`	`}`
`53`	`53`
`54`		`- ref_ptr<ArrayState> cloneArrayState() override`
`55`		`- {`
`56`		`- return GpuLayoutTechniqueArrayState::create(*this);`
`57`		`- }`
	`54`	`+ using Inherit::cloneArrayState;`
`58`	`55`
`59`	`56`	`ref_ptr<ArrayState> cloneArrayState(ref_ptr<ArrayState> arrayState) override`
`60`	`57`	`{`