Macros to simplify usage of class template AttachedVirtualFunction ...

... And allow correct linkage when overrides are defined in dynamically loaded
modules

libraries/lib-registries/AttachedVirtualFunction.h

@@ -72,13 +72,15 @@ AttachedVirtualFunction<
    AbstractHost, // class to be switched on by runtime type
    int, double // other arguments
 >;
+// Allow correct linkage for overrides defined in dynamically loaded modules:
+DECLARE_EXPORTED_ATTACHED_VIRTUAL(AUDACITY_DLL_API, DoSomething);
 ```
 
 Definitions needed:
 ```
 //file Client.cpp
-// Define the default function body here (as a function returning a function!)
-template<> auto DoSomething::Implementation() -> Function {
+// Define the default function body here
+DEFINE_ATTACHED_VIRTUAL(DoSomething) {
    return [](AbstractHost &host, int arg1, double arg2) {
       return ErrorCode::Ok;
    };
@@ -86,9 +88,6 @@ template<> auto DoSomething::Implementation() -> Function {
    // at runtime if the virtual function is invoked for a host subclass for which no override
    // was defined.
 }
-// Must also guarantee construction of an instance of class DoSomething at least
-// once before any use of DoSomething::Call()
-static DoSomething registerMe;
 ```
 
 Usage of the method somewhere else:
@@ -124,7 +123,7 @@ Overrides of the method, defined in any other .cpp file:
 // An override of the function, building up a hierarchy of function bodies parallel
 // to the host class hierarchy
 using DoSomethingSpecial = DoSomething::Override< SpecialHost >;
-template<> template<> auto DoSomethingSpecial::Implementation() -> Function {
+DEFINE_ATTACHED_VIRTUAL_OVERRIDE(DoSomethingSpecial) {
    // The function can be defined without casting the first argument
    return [](SpecialHost &host, int arg1, double arg2) {
       return arg1 == 0 ? ErrorCode::Ok : ErrorCode::Bad;
@@ -135,8 +134,7 @@ static DoSomethingSpecial registerMe;
 // A further override, demonstrating call-through too
 using DoSomethingExtraSpecial =
    DoSomething::Override< ExtraSpecialHost, DoSomethingSpecial >;
-template<> template<>
-auto DoSomethingExtraSpecial::Implementation() -> Function {
+DEFINE_ATTACHED_VIRTUAL_OVERRIDE(DoSomethingExtraSpecial) {
    return [](ExtraSpecialHost &host, int arg1, double arg2){
       // Call the immediately overridden version of the function
       auto result = Callthrough( host, arg1, arg2 );
@@ -173,11 +171,7 @@ public:
 
     //! At least one static instance must be created; more instances are harmless
     /*! (There will be others if there are any overrides.) */
-   AttachedVirtualFunction()
-   {
-      static std::once_flag flag;
-      std::call_once( flag, []{ Register<This>( Implementation() ); } );
-   }
+   AttachedVirtualFunction();
 
    //! For defining overrides of the method
    /*!
@@ -280,11 +274,33 @@ private:
    };
 
    using Registry = std::vector< Entry >;
-   static Registry &GetRegistry()
-   {
-      static Registry registry;
-      return registry;
-   }
+   static Registry &GetRegistry();
 };
 
+//! Typically follow the `using` declaration of a new AttachedVirtualFunction with this macro
+#define DECLARE_EXPORTED_ATTACHED_VIRTUAL(DECLSPEC, Name)      \
+   template<> DECLSPEC Name::AttachedVirtualFunction();        \
+   template<> auto DECLSPEC Name::GetRegistry() -> Registry &; \
+   template<> auto DECLSPEC Name::Implementation() -> Function
+
+//! Used in the companion .cpp file to the .h using the above macro; followed by a function body
+#define DEFINE_ATTACHED_VIRTUAL(Name)                          \
+   template<> Name::AttachedVirtualFunction()                  \
+   {                                                           \
+      static std::once_flag flag;                              \
+      std::call_once( flag, []{ Register<Object>( Implementation() ); } ); \
+   }                                                           \
+   template<> auto Name::GetRegistry() -> Registry &           \
+   {                                                           \
+      static Registry registry;                                \
+      return registry;                                         \
+   }                                                           \
+   static Name register ## Name ;                              \
+   template<> auto Name::Implementation() -> Function
+
+//! Used to define overriding function; followed by a function body
+#define DEFINE_ATTACHED_VIRTUAL_OVERRIDE(Name)                 \
+   static Name register ## Name ;                              \
+   template<> template<> auto Name::Implementation() -> Function \
+
 #endif

src/tracks/labeltrack/ui/LabelTrackControls.cpp

@@ -179,16 +179,14 @@ PopupMenuTable *LabelTrackControls::GetMenuExtension(Track *)
 }
 
 using DoGetLabelTrackControls = DoGetControls::Override< LabelTrack >;
-template<> template<> auto DoGetLabelTrackControls::Implementation() -> Function {
+DEFINE_ATTACHED_VIRTUAL_OVERRIDE(DoGetLabelTrackControls) {
    return [](LabelTrack &track) {
       return std::make_shared<LabelTrackControls>( track.SharedPointer() );
    };
 }
-static DoGetLabelTrackControls registerDoGetLabelTrackControls;
 
 using GetDefaultLabelTrackHeight = GetDefaultTrackHeight::Override< LabelTrack >;
-template<> template<>
-auto GetDefaultLabelTrackHeight::Implementation() -> Function {
+DEFINE_ATTACHED_VIRTUAL_OVERRIDE(GetDefaultLabelTrackHeight) {
    return [](LabelTrack &) {
       // Label tracks are narrow
       // Default is to allow two rows so that NEW users get the
@@ -196,4 +194,3 @@ auto GetDefaultLabelTrackHeight::Implementation() -> Function {
       return 73;
    };
 }
-static GetDefaultLabelTrackHeight registerGetDefaultLabelTrackHeight;

src/tracks/labeltrack/ui/LabelTrackShifter.cpp

@@ -248,9 +248,8 @@ private:
 };
 
 using MakeLabelTrackShifter = MakeTrackShifter::Override<LabelTrack>;
-template<> template<> auto MakeLabelTrackShifter::Implementation() -> Function {
+DEFINE_ATTACHED_VIRTUAL_OVERRIDE(MakeLabelTrackShifter) {
    return [](LabelTrack &track, AudacityProject &project) {
       return std::make_unique<LabelTrackShifter>(track, project);
    };
 }
-static MakeLabelTrackShifter registerMakeLabelTrackShifter;

src/tracks/labeltrack/ui/LabelTrackView.cpp

@@ -2290,12 +2290,11 @@ int LabelTrackView::DialogForLabelName(
 }
 
 using DoGetLabelTrackView = DoGetView::Override< LabelTrack >;
-template<> template<> auto DoGetLabelTrackView::Implementation() -> Function {
+DEFINE_ATTACHED_VIRTUAL_OVERRIDE(DoGetLabelTrackView) {
    return [](LabelTrack &track) {
       return std::make_shared<LabelTrackView>( track.SharedPointer() );
    };
 }
-static DoGetLabelTrackView registerDoGetLabelTrackView;
 
 std::shared_ptr<TrackVRulerControls> LabelTrackView::DoGetVRulerControls()
 {

src/tracks/playabletrack/notetrack/ui/NoteTrackControls.cpp

@@ -321,22 +321,19 @@ void NoteTrackControls::ReCreateVelocitySlider( wxEvent &evt )
 }
 
 using DoGetNoteTrackControls = DoGetControls::Override< NoteTrack >;
-template<> template<> auto DoGetNoteTrackControls::Implementation() -> Function {
+DEFINE_ATTACHED_VIRTUAL_OVERRIDE(DoGetNoteTrackControls) {
    return [](NoteTrack &track) {
       return std::make_shared<NoteTrackControls>( track.SharedPointer() );
    };
 }
-static DoGetNoteTrackControls registerDoGetNoteTrackControls;
 
 #include "../../../ui/TrackView.h"
 
 using GetDefaultNoteTrackHeight = GetDefaultTrackHeight::Override< NoteTrack >;
-template<> template<>
-auto GetDefaultNoteTrackHeight::Implementation() -> Function {
+DEFINE_ATTACHED_VIRTUAL_OVERRIDE(GetDefaultNoteTrackHeight) {
    return [](NoteTrack &) {
       return NoteTrackControls::DefaultNoteTrackHeight();
    };
 }
-static GetDefaultNoteTrackHeight registerGetDefaultNoteTrackHeight;
 
 #endif

src/tracks/playabletrack/notetrack/ui/NoteTrackShifter.cpp

@@ -54,9 +54,8 @@ private:
 };
 
 using MakeNoteTrackShifter = MakeTrackShifter::Override<NoteTrack>;
-template<> template<> auto MakeNoteTrackShifter::Implementation() -> Function {
+DEFINE_ATTACHED_VIRTUAL_OVERRIDE(MakeNoteTrackShifter) {
    return [](NoteTrack &track, AudacityProject&) {
       return std::make_unique<NoteTrackShifter>(track);
    };
 }
-static MakeNoteTrackShifter registerMakeNoteTrackShifter;

src/tracks/playabletrack/notetrack/ui/NoteTrackView.cpp

@@ -60,12 +60,11 @@ std::vector<UIHandlePtr> NoteTrackView::DetailedHitTest
 }
 
 using DoGetNoteTrackView = DoGetView::Override< NoteTrack >;
-template<> template<> auto DoGetNoteTrackView::Implementation() -> Function {
+DEFINE_ATTACHED_VIRTUAL_OVERRIDE(DoGetNoteTrackView) {
    return [](NoteTrack &track) {
       return std::make_shared<NoteTrackView>( track.SharedPointer() );
    };
 }
-static DoGetNoteTrackView registerDoGetNoteTrackView;
 
 std::shared_ptr<TrackVRulerControls> NoteTrackView::DoGetVRulerControls()
 {

src/tracks/playabletrack/wavetrack/ui/WaveTrackControls.cpp

@@ -1253,19 +1253,16 @@ void WaveTrackControls::ReCreatePanSlider( wxEvent &event )
 }
 
 using DoGetWaveTrackControls = DoGetControls::Override< WaveTrack >;
-template<> template<> auto DoGetWaveTrackControls::Implementation() -> Function {
+DEFINE_ATTACHED_VIRTUAL_OVERRIDE(DoGetWaveTrackControls) {
    return [](WaveTrack &track) {
       return std::make_shared<WaveTrackControls>( track.SharedPointer() );
    };
 }
-static DoGetWaveTrackControls registerDoGetWaveTrackControls;
 
 using GetDefaultWaveTrackHeight = GetDefaultTrackHeight::Override< WaveTrack >;
-template<> template<>
-auto GetDefaultWaveTrackHeight::Implementation() -> Function {
+DEFINE_ATTACHED_VIRTUAL_OVERRIDE(GetDefaultWaveTrackHeight) {
    return [](WaveTrack &) {
       return WaveTrackControls::DefaultWaveTrackHeight();
    };
 }
-static GetDefaultWaveTrackHeight registerGetDefaultWaveTrackHeight;
 

src/tracks/playabletrack/wavetrack/ui/WaveTrackShifter.cpp

@@ -188,9 +188,8 @@ private:
 };
 
 using MakeWaveTrackShifter = MakeTrackShifter::Override<WaveTrack>;
-template<> template<> auto MakeWaveTrackShifter::Implementation() -> Function {
+DEFINE_ATTACHED_VIRTUAL_OVERRIDE(MakeWaveTrackShifter) {
    return [](WaveTrack &track, AudacityProject&) {
       return std::make_unique<WaveTrackShifter>(track);
    };
 }
-static MakeWaveTrackShifter registerMakeWaveTrackShifter;

src/tracks/playabletrack/wavetrack/ui/WaveTrackView.cpp

@@ -1043,12 +1043,11 @@ void WaveTrackView::DoSetMinimized( bool minimized )
 }
 
 using DoGetWaveTrackView = DoGetView::Override< WaveTrack >;
-template<> template<> auto DoGetWaveTrackView::Implementation() -> Function {
+DEFINE_ATTACHED_VIRTUAL_OVERRIDE(DoGetWaveTrackView) {
    return [](WaveTrack &track) {
       return std::make_shared<WaveTrackView>( track.SharedPointer() );
    };
 }
-static DoGetWaveTrackView registerDoGetWaveTrackView;
 
 std::shared_ptr<TrackVRulerControls> WaveTrackView::DoGetVRulerControls()
 {

src/tracks/timetrack/ui/TimeTrackControls.cpp

@@ -170,20 +170,17 @@ PopupMenuTable *TimeTrackControls::GetMenuExtension(Track *)
 }
 
 using DoGetTimeTrackControls = DoGetControls::Override< TimeTrack >;
-template<> template<> auto DoGetTimeTrackControls::Implementation() -> Function {
+DEFINE_ATTACHED_VIRTUAL_OVERRIDE(DoGetTimeTrackControls) {
    return [](TimeTrack &track) {
       return std::make_shared<TimeTrackControls>( track.SharedPointer() );
    };
 }
-static DoGetTimeTrackControls registerDoGetTimeTrackControls;
 
 #include "../../ui/TrackView.h"
 
 using GetDefaultTimeTrackHeight = GetDefaultTrackHeight::Override< TimeTrack >;
-template<> template<>
-auto GetDefaultTimeTrackHeight::Implementation() -> Function {
+DEFINE_ATTACHED_VIRTUAL_OVERRIDE(GetDefaultTimeTrackHeight) {
    return [](TimeTrack &) {
       return 100;
    };
 }
-static GetDefaultTimeTrackHeight registerGetDefaultTimeTrackHeight;

src/tracks/timetrack/ui/TimeTrackView.cpp

@@ -53,12 +53,11 @@ std::vector<UIHandlePtr> TimeTrackView::DetailedHitTest
 }
 
 using DoGetTimeTrackView = DoGetView::Override< TimeTrack >;
-template<> template<> auto DoGetTimeTrackView::Implementation() -> Function {
+DEFINE_ATTACHED_VIRTUAL_OVERRIDE(DoGetTimeTrackView) {
    return [](TimeTrack &track) {
       return std::make_shared<TimeTrackView>( track.SharedPointer() );
    };
 }
-static DoGetTimeTrackView registerDoGetTimeTrackView;
 
 std::shared_ptr<TrackVRulerControls> TimeTrackView::DoGetVRulerControls()
 {

src/tracks/ui/TimeShiftHandle.cpp

@@ -272,12 +272,11 @@ bool CoarseTrackShifter::SyncLocks()
    return false;
 }
 
-template<> auto MakeTrackShifter::Implementation() -> Function {
+DEFINE_ATTACHED_VIRTUAL(MakeTrackShifter) {
    return [](Track &track, AudacityProject&) {
       return std::make_unique<CoarseTrackShifter>(track);
    };
 }
-static MakeTrackShifter registerMakeTrackShifter;
 
 void ClipMoveState::Init(
    AudacityProject &project,

src/tracks/ui/TimeShiftHandle.h

@@ -198,6 +198,7 @@ private:
 struct MakeTrackShifterTag;
 using MakeTrackShifter = AttachedVirtualFunction<
    MakeTrackShifterTag, std::unique_ptr<TrackShifter>, Track, AudacityProject&>;
+DECLARE_EXPORTED_ATTACHED_VIRTUAL(AUDACITY_DLL_API, MakeTrackShifter);
 
 class ViewInfo;
 

src/tracks/ui/TrackControls.cpp

@@ -37,7 +37,6 @@ const TrackControls &TrackControls::Get( const Track &track )
    return Get( const_cast< Track& >( track ) );
 }
 
-template<> auto DoGetControls::Implementation() -> Function {
+DEFINE_ATTACHED_VIRTUAL(DoGetControls) {
    return nullptr;
 }
-static DoGetControls registerDoGetControls;

src/tracks/ui/TrackControls.h

@@ -38,5 +38,6 @@ AttachedVirtualFunction<
    std::shared_ptr< TrackControls >,
    Track
 >;
+DECLARE_EXPORTED_ATTACHED_VIRTUAL(AUDACITY_DLL_API, DoGetControls);
 
 #endif

src/tracks/ui/TrackView.cpp

@@ -229,12 +229,10 @@ static const AudacityProject::AttachedObjects::RegisteredFactory key{
 
 }
 
-template<> auto DoGetView::Implementation() -> Function {
+DEFINE_ATTACHED_VIRTUAL(DoGetView) {
    return nullptr;
 }
-static DoGetView registerDoGetView;
 
-template<> auto GetDefaultTrackHeight::Implementation() -> Function {
+DEFINE_ATTACHED_VIRTUAL(GetDefaultTrackHeight) {
    return nullptr;
 }
-static GetDefaultTrackHeight registerGetDefaultTrackHeight;

src/tracks/ui/TrackView.h

@@ -113,6 +113,7 @@ AttachedVirtualFunction<
    std::shared_ptr< TrackView >,
    Track
 >;
+DECLARE_EXPORTED_ATTACHED_VIRTUAL(AUDACITY_DLL_API, DoGetView);
 
 struct GetDefaultTrackHeightTag;
 
@@ -122,5 +123,6 @@ AttachedVirtualFunction<
    int,
    Track
 >;
+DECLARE_EXPORTED_ATTACHED_VIRTUAL(AUDACITY_DLL_API, GetDefaultTrackHeight);
 
 #endif