Hide static data members

adazem009 · adazem009 · commit dde9c6c9a318 · 2025-09-02T18:08:11.000+02:00
diff --git a/src/blocks/eventblocks.cpp b/src/blocks/eventblocks.cpp
@@ -173,6 +173,16 @@ CompilerValue *EventBlocks::compileWhenKeyPressed(Compiler *compiler)
     return nullptr;
 }
 
+IAudioInput *EventBlocks::audioInput()
+{
+    return m_audioInput;
+}
+
+void EventBlocks::setAudioInput(IAudioInput *audioInput)
+{
+    m_audioInput = audioInput;
+}
+
 BLOCK_EXPORT bool event_whentouchingobject_predicate(Target *target, const StringPtr *name)
 {
     static const StringPtr MOUSE_STR = StringPtr("_mouse_");
@@ -198,10 +208,10 @@ BLOCK_EXPORT bool event_whentouchingobject_predicate(Target *target, const Strin
 
 BLOCK_EXPORT bool event_whengreaterthan_loudness_predicate(ExecutionContext *ctx, double value)
 {
-    if (!EventBlocks::audioInput)
-        EventBlocks::audioInput = AudioInput::instance().get();
+    if (!EventBlocks::audioInput())
+        EventBlocks::setAudioInput(AudioInput::instance().get());
 
-    auto audioLoudness = EventBlocks::audioInput->audioLoudness();
+    auto audioLoudness = EventBlocks::audioInput()->audioLoudness();
     return (audioLoudness->getLoudness() > value);
 }
 
diff --git a/src/blocks/eventblocks.h b/src/blocks/eventblocks.h
@@ -20,7 +20,8 @@ class LIBSCRATCHCPP_TEST_EXPORT EventBlocks : public IExtension
 
         void registerBlocks(IEngine *engine) override;
 
-        static inline IAudioInput *audioInput = nullptr;
+        static IAudioInput *audioInput();
+        static void setAudioInput(IAudioInput *audioInput);
 
     private:
         static CompilerValue *compileWhenTouchingObject(Compiler *compiler);
@@ -35,6 +36,8 @@ class LIBSCRATCHCPP_TEST_EXPORT EventBlocks : public IExtension
         static CompilerValue *compileBroadcast(Compiler *compiler);
         static CompilerValue *compileBroadcastAndWait(Compiler *compiler);
         static CompilerValue *compileWhenKeyPressed(Compiler *compiler);
+
+        static inline IAudioInput *m_audioInput = nullptr;
 };
 
 } // namespace libscratchcpp
diff --git a/src/blocks/sensingblocks.cpp b/src/blocks/sensingblocks.cpp
@@ -431,6 +431,26 @@ void SensingBlocks::askNextQuestion()
         engine->questionAsked()(question->question);
 }
 
+IAudioInput *SensingBlocks::audioInput()
+{
+    return m_audioInput;
+}
+
+void SensingBlocks::setAudioInput(IAudioInput *audioInput)
+{
+    m_audioInput = audioInput;
+}
+
+IClock *SensingBlocks::clock()
+{
+    return m_clock;
+}
+
+void SensingBlocks::setClock(IClock *clock)
+{
+    m_clock = clock;
+}
+
 BLOCK_EXPORT bool sensing_touching_mouse(Target *target)
 {
     IEngine *engine = target->engine();
@@ -556,10 +576,10 @@ BLOCK_EXPORT void sensing_setdragmode(Sprite *sprite, bool draggable)
 
 BLOCK_EXPORT double sensing_loudness()
 {
-    if (!SensingBlocks::audioInput)
-        SensingBlocks::audioInput = AudioInput::instance().get();
+    if (!SensingBlocks::audioInput())
+        SensingBlocks::setAudioInput(AudioInput::instance().get());
 
-    auto audioLoudness = SensingBlocks::audioInput->audioLoudness();
+    auto audioLoudness = SensingBlocks::audioInput()->audioLoudness();
     return audioLoudness->getLoudness();
 }
 
@@ -773,9 +793,9 @@ BLOCK_EXPORT double sensing_current_second()
 
 BLOCK_EXPORT double sensing_dayssince2000()
 {
-    if (!SensingBlocks::clock)
-        SensingBlocks::clock = Clock::instance().get();
+    if (!SensingBlocks::clock())
+        SensingBlocks::setClock(Clock::instance().get());
 
-    auto ms = std::chrono::duration_cast<std::chrono::milliseconds>(SensingBlocks::clock->currentSystemTime().time_since_epoch()).count();
+    auto ms = std::chrono::duration_cast<std::chrono::milliseconds>(SensingBlocks::clock()->currentSystemTime().time_since_epoch()).count();
     return ms / 86400000.0 - 10957.0;
 }
diff --git a/src/blocks/sensingblocks.h b/src/blocks/sensingblocks.h
@@ -29,8 +29,11 @@ class LIBSCRATCHCPP_TEST_EXPORT SensingBlocks : public IExtension
         static void clearQuestions();
         static void askQuestion(ExecutionContext *ctx, const StringPtr *question);
 
-        static inline IAudioInput *audioInput = nullptr;
-        static inline IClock *clock = nullptr;
+        static IAudioInput *audioInput();
+        static void setAudioInput(IAudioInput *audioInput);
+
+        static IClock *clock();
+        static void setClock(IClock *clock);
 
     private:
         struct Question
@@ -73,6 +76,9 @@ class LIBSCRATCHCPP_TEST_EXPORT SensingBlocks : public IExtension
         static void askNextQuestion();
 
         static inline std::vector<std::unique_ptr<Question>> m_questions;
+
+        static inline IAudioInput *m_audioInput = nullptr;
+        static inline IClock *m_clock = nullptr;
 };
 
 } // namespace libscratchcpp
diff --git a/src/engine/compiler.cpp b/src/engine/compiler.cpp
@@ -60,7 +60,7 @@ std::shared_ptr<ExecutableCode> Compiler::compile(Block *startBlock, CodeType co
         }
     }
 
-    impl->builder = impl->builderFactory->create(impl->ctx, procedurePrototype, codeType);
+    impl->builder = impl->builderFactory()->create(impl->ctx, procedurePrototype, codeType);
     impl->substackTree.clear();
     impl->substackHit = false;
     impl->emptySubstack = false;
@@ -743,5 +743,5 @@ const std::unordered_set<std::string> &Compiler::unsupportedBlocks() const
 std::shared_ptr<CompilerContext> Compiler::createContext(IEngine *engine, Target *target)
 {
     CompilerPrivate::initBuilderFactory();
-    return CompilerPrivate::builderFactory->createCtx(engine, target);
+    return CompilerPrivate::builderFactory()->createCtx(engine, target);
 }
diff --git a/src/engine/compiler_p.cpp b/src/engine/compiler_p.cpp
@@ -26,8 +26,8 @@ CompilerPrivate::CompilerPrivate(IEngine *engine, Target *target) :
 
 void CompilerPrivate::initBuilderFactory()
 {
-    if (!builderFactory)
-        builderFactory = CodeBuilderFactory::instance().get();
+    if (!m_builderFactory)
+        m_builderFactory = CodeBuilderFactory::instance().get();
 }
 
 void CompilerPrivate::substackEnd()
@@ -67,3 +67,13 @@ void CompilerPrivate::substackEnd()
     if (!block && !substackTree.empty())
         substackEnd();
 }
+
+ICodeBuilderFactory *CompilerPrivate::builderFactory()
+{
+    return m_builderFactory;
+}
+
+void CompilerPrivate::setBuilderFactory(ICodeBuilderFactory *builderFactory)
+{
+    m_builderFactory = builderFactory;
+}
diff --git a/src/engine/compiler_p.h b/src/engine/compiler_p.h
@@ -6,6 +6,8 @@
 #include <vector>
 #include <unordered_set>
 
+#include "test_export.h"
+
 namespace libscratchcpp
 {
 
@@ -17,8 +19,9 @@ class CompilerValue;
 class ICodeBuilderFactory;
 class ICodeBuilder;
 
-struct CompilerPrivate
+class LIBSCRATCHCPP_TEST_EXPORT CompilerPrivate
 {
+    public:
         enum class SubstackType
         {
             Loop,
@@ -43,10 +46,15 @@ struct CompilerPrivate
         bool emptySubstack = false;
         bool warp = false;
 
-        static inline ICodeBuilderFactory *builderFactory = nullptr;
         std::shared_ptr<ICodeBuilder> builder;
 
         std::unordered_set<std::string> unsupportedBlocks;
+
+        static ICodeBuilderFactory *builderFactory();
+        static void setBuilderFactory(ICodeBuilderFactory *builderFactory);
+
+    private:
+        static inline ICodeBuilderFactory *m_builderFactory = nullptr;
 };
 
 } // namespace libscratchcpp
diff --git a/src/project_p.cpp b/src/project_p.cpp
@@ -13,15 +13,13 @@
 
 using namespace libscratchcpp;
 
-IProjectDownloaderFactory *ProjectPrivate::downloaderFactory = nullptr;
-
 ProjectPrivate::ProjectPrivate() :
     engine(std::make_shared<Engine>())
 {
-    if (!downloaderFactory)
-        downloaderFactory = ProjectDownloaderFactory::instance().get();
+    if (!m_downloaderFactory)
+        m_downloaderFactory = ProjectDownloaderFactory::instance().get();
 
-    downloader = downloaderFactory->create();
+    downloader = m_downloaderFactory->create();
 }
 
 ProjectPrivate::ProjectPrivate(const std::string &fileName) :
@@ -194,3 +192,13 @@ sigslot::signal<unsigned int, unsigned int> &ProjectPrivate::downloadProgressCha
 {
     return downloader->downloadProgressChanged();
 }
+
+IProjectDownloaderFactory *ProjectPrivate::downloaderFactory()
+{
+    return m_downloaderFactory;
+}
+
+void ProjectPrivate::setDownloaderFactory(IProjectDownloaderFactory *downloaderFactory)
+{
+    m_downloaderFactory = downloaderFactory;
+}
diff --git a/src/project_p.h b/src/project_p.h
@@ -15,8 +15,9 @@ class IProjectReader;
 class IProjectDownloaderFactory;
 class IProjectDownloader;
 
-struct LIBSCRATCHCPP_TEST_EXPORT ProjectPrivate
+class LIBSCRATCHCPP_TEST_EXPORT ProjectPrivate
 {
+    public:
         ProjectPrivate();
         ProjectPrivate(const std::string &fileName);
         ProjectPrivate(const ProjectPrivate &) = delete;
@@ -35,8 +36,13 @@ struct LIBSCRATCHCPP_TEST_EXPORT ProjectPrivate
         std::atomic<bool> stopLoading = false;
         std::shared_ptr<IEngine> engine = nullptr;
 
-        static IProjectDownloaderFactory *downloaderFactory;
         std::shared_ptr<IProjectDownloader> downloader;
+
+        static IProjectDownloaderFactory *downloaderFactory();
+        static void setDownloaderFactory(IProjectDownloaderFactory *downloaderFactory);
+
+    private:
+        static inline IProjectDownloaderFactory *m_downloaderFactory = nullptr;
 };
 
 }; // namespace libscratchcpp
diff --git a/src/scratch/sound_p.cpp b/src/scratch/sound_p.cpp
@@ -5,13 +5,16 @@
 
 using namespace libscratchcpp;
 
-IAudioOutput *SoundPrivate::audioOutput = nullptr;
-
 SoundPrivate::SoundPrivate()
 {
     // NOTE: audioOutput must be initialized in the constructor to avoid static initialization order fiasco
-    if (!audioOutput)
-        audioOutput = AudioOutput::instance().get();
+    if (!m_audioOutput)
+        m_audioOutput = AudioOutput::instance().get();
+
+    player = m_audioOutput->createAudioPlayer();
+}
 
-    player = audioOutput->createAudioPlayer();
+void SoundPrivate::setAudioOutput(IAudioOutput *audioOutput)
+{
+    m_audioOutput = audioOutput;
 }
diff --git a/src/scratch/sound_p.h b/src/scratch/sound_p.h
@@ -14,17 +14,22 @@ namespace libscratchcpp
 class Sound;
 class Thread;
 
-struct LIBSCRATCHCPP_TEST_EXPORT SoundPrivate
+class LIBSCRATCHCPP_TEST_EXPORT SoundPrivate
 {
+    public:
         SoundPrivate();
         SoundPrivate(const SoundPrivate &) = delete;
 
         int rate = 0;
         int sampleCount = 0;
-        static IAudioOutput *audioOutput;
         std::shared_ptr<IAudioPlayer> player = nullptr;
         const Sound *cloneRoot = nullptr;
         Thread *owner = nullptr;
+
+        static void setAudioOutput(IAudioOutput *newAudioOutput);
+
+    private:
+        static inline IAudioOutput *m_audioOutput = nullptr;
 };
 
 } // namespace libscratchcpp
diff --git a/test/assets/sound_test.cpp b/test/assets/sound_test.cpp
@@ -18,11 +18,11 @@ class SoundTest : public testing::Test
         void SetUp() override
         {
             m_player = std::make_shared<AudioPlayerMock>();
-            SoundPrivate::audioOutput = &m_playerFactory;
+            SoundPrivate::setAudioOutput(&m_playerFactory);
             EXPECT_CALL(m_playerFactory, createAudioPlayer()).WillOnce(Return(m_player));
         }
 
-        void TearDown() override { SoundPrivate::audioOutput = nullptr; }
+        void TearDown() override { SoundPrivate::setAudioOutput(nullptr); }
 
         AudioOutputMock m_playerFactory;
         std::shared_ptr<AudioPlayerMock> m_player;
@@ -170,8 +170,6 @@ TEST_F(SoundTest, IsPlaying)
 
     EXPECT_CALL(*m_player, isPlaying()).WillOnce(Return(false));
     ASSERT_FALSE(sound.isPlaying());
-
-    SoundPrivate::audioOutput = nullptr;
 }
 
 TEST_F(SoundTest, Clone)
diff --git a/test/blocks/event_blocks_test.cpp b/test/blocks/event_blocks_test.cpp
@@ -264,7 +264,7 @@ TEST_F(EventBlocksTest, WhenGreaterThanPredicate)
 
     AudioInputMock audioInput;
     auto audioLoudness = std::make_shared<AudioLoudnessMock>();
-    EventBlocks::audioInput = &audioInput;
+    EventBlocks::setAudioInput(&audioInput);
     EXPECT_CALL(audioInput, audioLoudness()).Times(3).WillRepeatedly(Return(audioLoudness));
     EXPECT_CALL(*audioLoudness, getLoudness()).Times(3).WillRepeatedly(Return(23));
 
@@ -285,7 +285,7 @@ TEST_F(EventBlocksTest, WhenGreaterThanPredicate)
         ASSERT_EQ(thread.runPredicate(), retValues[i]);
     }
 
-    EventBlocks::audioInput = nullptr;
+    EventBlocks::setAudioInput(nullptr);
 
     TimerMock timer;
     EXPECT_CALL(m_engineMock, timer()).Times(3).WillRepeatedly(Return(&timer));
diff --git a/test/blocks/sensing_blocks_test.cpp b/test/blocks/sensing_blocks_test.cpp
@@ -43,19 +43,19 @@ class SensingBlocksTest : public testing::Test
             registerBlocks(m_engine, m_extension.get());
 
             m_audioLoudness = std::make_shared<AudioLoudnessMock>();
-            SensingBlocks::audioInput = &m_audioInput;
+            SensingBlocks::setAudioInput(&m_audioInput);
             EXPECT_CALL(m_audioInput, audioLoudness()).WillRepeatedly(Return(m_audioLoudness));
 
-            SensingBlocks::clock = &m_clock;
+            SensingBlocks::setClock(&m_clock);
 
             EXPECT_CALL(m_engineMock, targets()).WillRepeatedly(ReturnRef(m_engine->targets()));
         }
 
         void TearDown() override
         {
             SensingBlocks::clearQuestions();
-            SensingBlocks::audioInput = nullptr;
-            SensingBlocks::clock = nullptr;
+            SensingBlocks::setAudioInput(nullptr);
+            SensingBlocks::setClock(nullptr);
         }
 
         std::unique_ptr<IExtension> m_extension;
diff --git a/test/blocks/sound_blocks_test.cpp b/test/blocks/sound_blocks_test.cpp
@@ -30,10 +30,10 @@ class SoundBlocksTest : public testing::Test
             m_extension->registerBlocks(m_engine);
             m_extension->onInit(m_engine);
 
-            SoundPrivate::audioOutput = &m_outputMock;
+            SoundPrivate::setAudioOutput(&m_outputMock);
         }
 
-        void TearDown() override { SoundPrivate::audioOutput = nullptr; }
+        void TearDown() override { SoundPrivate::setAudioOutput(nullptr); }
 
         std::unique_ptr<IExtension> m_extension;
         Project m_project;
diff --git a/test/compiler/compiler_test.cpp b/test/compiler/compiler_test.cpp
diff --git a/test/engine/engine_test.cpp b/test/engine/engine_test.cpp
diff --git a/test/load_project/load_project_test.cpp b/test/load_project/load_project_test.cpp
diff --git a/test/project/project_test.cpp b/test/project/project_test.cpp
diff --git a/test/scratch_classes/inputvalue_test.cpp b/test/scratch_classes/inputvalue_test.cpp
diff --git a/test/scratch_classes/target_test.cpp b/test/scratch_classes/target_test.cpp

Original file line number	Diff line number	Diff line change
`@@ -60,7 +60,7 @@ std::shared_ptr<ExecutableCode> Compiler::compile(Block *startBlock, CodeType co`
`60`	`60`	`}`
`61`	`61`	`}`
`62`	`62`
`63`		`- impl->builder = impl->builderFactory->create(impl->ctx, procedurePrototype, codeType);`
	`63`	`+ impl->builder = impl->builderFactory()->create(impl->ctx, procedurePrototype, codeType);`
`64`	`64`	`impl->substackTree.clear();`
`65`	`65`	`impl->substackHit = false;`
`66`	`66`	`impl->emptySubstack = false;`
`@@ -743,5 +743,5 @@ const std::unordered_set<std::string> &Compiler::unsupportedBlocks() const`
`743`	`743`	`std::shared_ptr<CompilerContext> Compiler::createContext(IEngine engine, Target target)`
`744`	`744`	`{`
`745`	`745`	`CompilerPrivate::initBuilderFactory();`
`746`		`- return CompilerPrivate::builderFactory->createCtx(engine, target);`
	`746`	`+ return CompilerPrivate::builderFactory()->createCtx(engine, target);`
`747`	`747`	`}`