Skip to main content

App - Reflection System

ClassDescriptor, MemberDescriptor, PropertyDescriptor, and dynamic invocation.

Subsystem Metrics​

  • Total Documented Functions: 380
  • Functions Exercised in Tests: 95
  • Platform-Divergent Implementations: 20
  • Component Source Files: 16

Source Files​

View all 16 source files in this subsystem
Source FilePath
Callback.hApp/include/reflection/Callback.h
Descriptor.hApp/include/reflection/Descriptor.h
EnumConverter.hApp/include/reflection/EnumConverter.h
Event.hApp/include/reflection/Event.h
Function.hApp/include/reflection/Function.h
Object.hApp/include/reflection/Object.h
Property.hApp/include/reflection/Property.h
Type.hApp/include/reflection/Type.h
YieldFunction.hApp/include/reflection/YieldFunction.h
member.hApp/include/reflection/member.h
reflection.hApp/include/reflection/reflection.h
Callback.cppApp/reflection/Callback.cpp
Event.cppApp/reflection/Event.cpp
reflection_object.cppApp/reflection/reflection_object.cpp
reflection_property.cppApp/reflection/reflection_property.cpp
type.cppApp/reflection/type.cpp

Function Reference​

1. getSignature​

Status: ⚪ Untested in Suites  |  🌐 Cross-Platform Uniform

SignatureDescriptor& getSignature() const;
PropertyValue
Return TypeSignatureDescriptor&
Modifiersinline const const
Source LocationApp/include/reflection/Callback.h:29
SubsystemApp - Reflection System

How it Works Internally​

Executes getSignature within App - Reflection System.

  • Control Flow & Execution: Explicit result return.
  • Memory Management: Stack-based automatic variable allocation.
  • Concurrency & Thread Safety: Unsynchronized execution (caller must ensure thread-safety if shared).
  • Error Handling & Invariants: Relies on standard return codes and caller validation.
  • State Mutation: Immutable / read-only operation (const member method; does not alter object state).

How it is Used in Tests​

No dedicated unit test case directly exercises this function by name.

Verification Note

This function is invoked indirectly through higher-level simulation or integration workloads. To add direct test coverage, introduce a test case in App.UnitTest or Base.UnitTest asserting state changes on getSignature.

Behavioral Differences Across Code Files​

This function maintains identical behavior across all target platforms (_WIN32, macOS, iOS, Android, and Xbox Durango). It compiles into the same binary instructions without conditional preprocessor branching.


2. isAsync​

Status: ⚪ Untested in Suites  |  🌐 Cross-Platform Uniform

bool isAsync() const;
PropertyValue
Return Typebool
Modifiersconst
Source LocationApp/include/reflection/Callback.h:30
SubsystemApp - Reflection System

How it Works Internally​

Executes isAsync within App - Reflection System.

  • Control Flow & Execution: Explicit result return.
  • Memory Management: Stack-based automatic variable allocation.
  • Concurrency & Thread Safety: Unsynchronized execution (caller must ensure thread-safety if shared).
  • Error Handling & Invariants: Relies on standard return codes and caller validation.
  • State Mutation: Immutable / read-only operation (const member method; does not alter object state).

How it is Used in Tests​

No dedicated unit test case directly exercises this function by name.

Verification Note

This function is invoked indirectly through higher-level simulation or integration workloads. To add direct test coverage, introduce a test case in App.UnitTest or Base.UnitTest asserting state changes on isAsync.

Behavioral Differences Across Code Files​

This function maintains identical behavior across all target platforms (_WIN32, macOS, iOS, Android, and Xbox Durango). It compiles into the same binary instructions without conditional preprocessor branching.


3. getName​

Status: 🧪 Tested  |  ⚠️ Platform Divergent

RBX::Name& getName() const;
PropertyValue
Return TypeRBX::Name&
Modifiersinline const const
Source LocationApp/include/reflection/Callback.h:102
SubsystemApp - Reflection System

How it Works Internally​

Executes getName within App - Reflection System.

  • Control Flow & Execution: Explicit result return.
  • Memory Management: Stack-based automatic variable allocation.
  • Concurrency & Thread Safety: Unsynchronized execution (caller must ensure thread-safety if shared).
  • Error Handling & Invariants: Relies on standard return codes and caller validation.
  • State Mutation: Immutable / read-only operation (const member method; does not alter object state).

How it is Used in Tests​

This function is exercised in 19 test case(s):

  • Instance::WaitForChildReturnsImmediatelyIfChildPresent (App.UnitTest/Instance.cpp:264)
    • Usage Pattern: Direct Assertion
    • Assertions Checked: BOOST_CHECK_EQUAL(part->getName(), "Renamed")
    • Callsite Snippet: BOOST_CHECK_EQUAL(part->getName(), "Renamed");
  • Instance::WaitForSameChildAfterInitialWaitForChild (App.UnitTest/Instance.cpp:289)
    • Usage Pattern: Direct Assertion
    • Assertions Checked: BOOST_CHECK_EQUAL(part->getName(), "Renamed")
    • Callsite Snippet: BOOST_CHECK_EQUAL(part->getName(), "Renamed");
  • Instance::TwoScriptsWaitingForSameChildRenameOnResume (App.UnitTest/Instance.cpp:356)
    • Usage Pattern: Direct Assertion
    • Assertions Checked: BOOST_CHECK_EQUAL("PartBx", part->getName()), BOOST_CHECK_EQUAL("PartA", part2->getName())
    • Callsite Snippet: BOOST_CHECK_EQUAL("PartBx", part->getName());
  • Instance::WaitForDifferentChildAfterInitialWaitForChild (App.UnitTest/Instance.cpp:478)
    • Usage Pattern: Direct Assertion
    • Assertions Checked: BOOST_CHECK_EQUAL(part->getName(), "Phase1"), BOOST_CHECK_EQUAL(part->getName(), "Phase2")
    • Callsite Snippet: BOOST_CHECK_EQUAL(part->getName(), "Phase1");

Behavioral Differences Across Code Files​

Divergence Analysis: Alternative platform-specific implementations exist in: RobloxStudio/RobloxRibbonMainWindow.cpp.

  • Alternative Implementation Files: RobloxStudio/RobloxRibbonMainWindow.cpp

4. getInstance​

Status: ⚪ Untested in Suites  |  🌐 Cross-Platform Uniform

DescribedBase* getInstance() const;
PropertyValue
Return TypeDescribedBase*
Modifiersinline const
Source LocationApp/include/reflection/Callback.h:106
SubsystemApp - Reflection System

How it Works Internally​

Executes getInstance within App - Reflection System.

  • Control Flow & Execution: Explicit result return.
  • Memory Management: Stack-based automatic variable allocation.
  • Concurrency & Thread Safety: Unsynchronized execution (caller must ensure thread-safety if shared).
  • Error Handling & Invariants: Relies on standard return codes and caller validation.
  • State Mutation: Immutable / read-only operation (const member method; does not alter object state).

How it is Used in Tests​

No dedicated unit test case directly exercises this function by name.

Verification Note

This function is invoked indirectly through higher-level simulation or integration workloads. To add direct test coverage, introduce a test case in App.UnitTest or Base.UnitTest asserting state changes on getInstance.

Behavioral Differences Across Code Files​

This function maintains identical behavior across all target platforms (_WIN32, macOS, iOS, Android, and Xbox Durango). It compiles into the same binary instructions without conditional preprocessor branching.


5. getDescriptor​

Status: 🧪 Tested  |  🌐 Cross-Platform Uniform

CallbackDescriptor& getDescriptor() const;
PropertyValue
Return TypeCallbackDescriptor&
Modifiersinline const const
Source LocationApp/include/reflection/Callback.h:111
SubsystemApp - Reflection System

How it Works Internally​

Executes getDescriptor within App - Reflection System.

  • Control Flow & Execution: Explicit result return.
  • Memory Management: Stack-based automatic variable allocation.
  • Concurrency & Thread Safety: Unsynchronized execution (caller must ensure thread-safety if shared).
  • Error Handling & Invariants: Relies on standard return codes and caller validation.
  • State Mutation: Immutable / read-only operation (const member method; does not alter object state).

How it is Used in Tests​

This function is exercised in 2 test case(s):

  • Reflection::HideMember (App.UnitTest/ReflectionTest.cpp:121)
    • Usage Pattern: Direct Assertion
    • Assertions Checked: BOOST_CHECK_EQUAL(&prop.getDescriptor(), &prop0), BOOST_CHECK_EQUAL(&prop.getDescriptor(), &prop1)
    • Callsite Snippet: BOOST_CHECK_EQUAL(&prop.getDescriptor(), &prop0);
  • Instance::PerfIsA (App.UnitTest/InstanceTest.cpp:38)
    • Usage Pattern: Performance Benchmark
    • Callsite Snippet: inst->getDescriptor().isA(RBX::PartInstance::classDescriptor());

Behavioral Differences Across Code Files​

This function maintains identical behavior across all target platforms (_WIN32, macOS, iOS, Android, and Xbox Durango). It compiles into the same binary instructions without conditional preprocessor branching.


6. ~ISetter​

Status: ⚪ Untested in Suites  |  🌐 Cross-Platform Uniform

public:
virtual ~ISetter();
PropertyValue
Return Type`public:
virtual`
ModifiersNone
Source LocationApp/include/reflection/Callback.h:161
SubsystemApp - Reflection System

How it Works Internally​

Declaration or inline method for ~ISetter.

  • Control Flow & Execution: Linear execution flow.
  • Memory Management: Standard stack allocation.
  • Concurrency & Thread Safety: Unsynchronized / single-threaded context.
  • Error Handling & Invariants: Standard return value verification.
  • State Mutation: Stateless or local modification.

How it is Used in Tests​

No dedicated unit test case directly exercises this function by name.

Verification Note

This function is invoked indirectly through higher-level simulation or integration workloads. To add direct test coverage, introduce a test case in App.UnitTest or Base.UnitTest asserting state changes on ~ISetter.

Behavioral Differences Across Code Files​

This function maintains identical behavior across all target platforms (_WIN32, macOS, iOS, Android, and Xbox Durango). It compiles into the same binary instructions without conditional preprocessor branching.


7. setCallback​

Status: 🧪 Tested  |  🌐 Cross-Platform Uniform

public:
void setCallback(DescribedBase* object, const Function& value) const;
PropertyValue
Return Type`public:
void`
Modifiersconst
Source LocationApp/include/reflection/Callback.h:170
SubsystemApp - Reflection System

How it Works Internally​

Executes setCallback within App - Reflection System.

  • Control Flow & Execution: Direct sequential execution.
  • Memory Management: Stack-based automatic variable allocation.
  • Concurrency & Thread Safety: Unsynchronized execution (caller must ensure thread-safety if shared).
  • Error Handling & Invariants: Relies on standard return codes and caller validation.
  • State Mutation: Immutable / read-only operation (const member method; does not alter object state).

How it is Used in Tests​

This function is exercised in 1 test case(s):

  • Reflection::Callbacks (App.UnitTest/ReflectionTest.cpp:135)
    • Usage Pattern: Direct Call
    • Assertions Checked: BOOST_CHECK_EQUAL(test.func0, f0), BOOST_CHECK_EQUAL(test.func1, f1)
    • Callsite Snippet: desc0.setCallback(&test, f0);

Behavioral Differences Across Code Files​

This function maintains identical behavior across all target platforms (_WIN32, macOS, iOS, Android, and Xbox Durango). It compiles into the same binary instructions without conditional preprocessor branching.


8. clearCallback​

Status: ⚪ Untested in Suites  |  🌐 Cross-Platform Uniform

void clearCallback(DescribedBase* object) const;
PropertyValue
Return Typevoid
Modifiersconst
Source LocationApp/include/reflection/Callback.h:175
SubsystemApp - Reflection System

How it Works Internally​

Executes clearCallback within App - Reflection System. Coordinates interactions with setCallback, Function.

  • Control Flow & Execution: Direct sequential execution.
  • Memory Management: Stack-based automatic variable allocation.
  • Concurrency & Thread Safety: Unsynchronized execution (caller must ensure thread-safety if shared).
  • Error Handling & Invariants: Relies on standard return codes and caller validation.
  • State Mutation: Immutable / read-only operation (const member method; does not alter object state).
  • Key Internal Calls: setCallback, Function.

How it is Used in Tests​

No dedicated unit test case directly exercises this function by name.

Verification Note

This function is invoked indirectly through higher-level simulation or integration workloads. To add direct test coverage, introduce a test case in App.UnitTest or Base.UnitTest asserting state changes on clearCallback.

Behavioral Differences Across Code Files​

This function maintains identical behavior across all target platforms (_WIN32, macOS, iOS, Android, and Xbox Durango). It compiles into the same binary instructions without conditional preprocessor branching.


9. callGeneric​

Status: ⚪ Untested in Suites  |  🌐 Cross-Platform Uniform

result_type callGeneric(shared_ptr<SyncCallbackDescriptor::GenericFunction> function);
PropertyValue
Return Typeresult_type
Modifiersstatic
Source LocationApp/include/reflection/Callback.h:189
SubsystemApp - Reflection System

How it Works Internally​

Executes callGeneric within App - Reflection System. Coordinates interactions with args, Tuple. Employs dynamic heap allocation via c++ operator new.

  • Control Flow & Execution: Explicit result return.
  • Memory Management: Dynamic heap allocation via C++ operator new; Reference-counted heap object ownership (boost::shared_ptr).
  • Concurrency & Thread Safety: Unsynchronized execution (caller must ensure thread-safety if shared).
  • Error Handling & Invariants: Relies on standard return codes and caller validation.
  • State Mutation: Pure computational logic or modifies passed-in parameters/references.
  • Key Internal Calls: args, Tuple.

How it is Used in Tests​

No dedicated unit test case directly exercises this function by name.

Verification Note

This function is invoked indirectly through higher-level simulation or integration workloads. To add direct test coverage, introduce a test case in App.UnitTest or Base.UnitTest asserting state changes on callGeneric.

Behavioral Differences Across Code Files​

This function maintains identical behavior across all target platforms (_WIN32, macOS, iOS, Android, and Xbox Durango). It compiles into the same binary instructions without conditional preprocessor branching.


10. setGenericCallback​

Status: ⚪ Untested in Suites  |  🌐 Cross-Platform Uniform

void setGenericCallback(DescribedBase* object, shared_ptr<SyncCallbackDescriptor::GenericFunction> function) const;
PropertyValue
Return Typevoid
Modifiersvirtual const
Source LocationApp/include/reflection/Callback.h:203
SubsystemApp - Reflection System

How it Works Internally​

Executes setGenericCallback within App - Reflection System. Coordinates interactions with setCallback, bind.

  • Control Flow & Execution: Direct sequential execution.
  • Memory Management: Stack-based automatic variable allocation.
  • Concurrency & Thread Safety: Unsynchronized execution (caller must ensure thread-safety if shared).
  • Error Handling & Invariants: Relies on standard return codes and caller validation.
  • State Mutation: Immutable / read-only operation (const member method; does not alter object state).
  • Key Internal Calls: setCallback, bind.
  • External Library Dependencies: Boost C++ Libraries.

How it is Used in Tests​

No dedicated unit test case directly exercises this function by name.

Verification Note

This function is invoked indirectly through higher-level simulation or integration workloads. To add direct test coverage, introduce a test case in App.UnitTest or Base.UnitTest asserting state changes on setGenericCallback.

Behavioral Differences Across Code Files​

This function maintains identical behavior across all target platforms (_WIN32, macOS, iOS, Android, and Xbox Durango). It compiles into the same binary instructions without conditional preprocessor branching.


11. callGeneric​

Status: ⚪ Untested in Suites  |  🌐 Cross-Platform Uniform

result_type callGeneric(shared_ptr<SyncCallbackDescriptor::GenericFunction> function,
// TODO: Use const ref for args and bind with boost::cref?
typename boost::function_traits<Signature>::arg1_type arg1);
PropertyValue
Return Typeresult_type
Modifiersstatic
Source LocationApp/include/reflection/Callback.h:213
SubsystemApp - Reflection System

How it Works Internally​

Executes callGeneric within App - Reflection System. Coordinates interactions with args, Tuple, push_back. Employs dynamic heap allocation via c++ operator new.

  • Control Flow & Execution: Explicit result return.
  • Memory Management: Dynamic heap allocation via C++ operator new; Reference-counted heap object ownership (boost::shared_ptr).
  • Concurrency & Thread Safety: Unsynchronized execution (caller must ensure thread-safety if shared).
  • Error Handling & Invariants: Relies on standard return codes and caller validation.
  • State Mutation: Pure computational logic or modifies passed-in parameters/references.
  • Key Internal Calls: args, Tuple, push_back.

How it is Used in Tests​

No dedicated unit test case directly exercises this function by name.

Verification Note

This function is invoked indirectly through higher-level simulation or integration workloads. To add direct test coverage, introduce a test case in App.UnitTest or Base.UnitTest asserting state changes on callGeneric.

Behavioral Differences Across Code Files​

This function maintains identical behavior across all target platforms (_WIN32, macOS, iOS, Android, and Xbox Durango). It compiles into the same binary instructions without conditional preprocessor branching.


12. setGenericCallback​

Status: ⚪ Untested in Suites  |  🌐 Cross-Platform Uniform

void setGenericCallback(DescribedBase* object, shared_ptr<SyncCallbackDescriptor::GenericFunction> function) const;
PropertyValue
Return Typevoid
Modifiersvirtual const
Source LocationApp/include/reflection/Callback.h:231
SubsystemApp - Reflection System

How it Works Internally​

Executes setGenericCallback within App - Reflection System. Coordinates interactions with setCallback, bind.

  • Control Flow & Execution: Direct sequential execution.
  • Memory Management: Stack-based automatic variable allocation.
  • Concurrency & Thread Safety: Unsynchronized execution (caller must ensure thread-safety if shared).
  • Error Handling & Invariants: Relies on standard return codes and caller validation.
  • State Mutation: Immutable / read-only operation (const member method; does not alter object state).
  • Key Internal Calls: setCallback, bind.
  • External Library Dependencies: Boost C++ Libraries.

How it is Used in Tests​

No dedicated unit test case directly exercises this function by name.

Verification Note

This function is invoked indirectly through higher-level simulation or integration workloads. To add direct test coverage, introduce a test case in App.UnitTest or Base.UnitTest asserting state changes on setGenericCallback.

Behavioral Differences Across Code Files​

This function maintains identical behavior across all target platforms (_WIN32, macOS, iOS, Android, and Xbox Durango). It compiles into the same binary instructions without conditional preprocessor branching.


13. callGeneric​

Status: ⚪ Untested in Suites  |  🌐 Cross-Platform Uniform

result_type callGeneric(shared_ptr<SyncCallbackDescriptor::GenericFunction> function,
typename boost::function_traits<Signature>::arg1_type arg1,
typename boost::function_traits<Signature>::arg2_type arg2);
PropertyValue
Return Typeresult_type
Modifiersstatic
Source LocationApp/include/reflection/Callback.h:241
SubsystemApp - Reflection System

How it Works Internally​

Executes callGeneric within App - Reflection System. Coordinates interactions with args, Tuple, push_back. Employs dynamic heap allocation via c++ operator new.

  • Control Flow & Execution: Explicit result return.
  • Memory Management: Dynamic heap allocation via C++ operator new; Reference-counted heap object ownership (boost::shared_ptr).
  • Concurrency & Thread Safety: Unsynchronized execution (caller must ensure thread-safety if shared).
  • Error Handling & Invariants: Relies on standard return codes and caller validation.
  • State Mutation: Pure computational logic or modifies passed-in parameters/references.
  • Key Internal Calls: args, Tuple, push_back.

How it is Used in Tests​

No dedicated unit test case directly exercises this function by name.

Verification Note

This function is invoked indirectly through higher-level simulation or integration workloads. To add direct test coverage, introduce a test case in App.UnitTest or Base.UnitTest asserting state changes on callGeneric.

Behavioral Differences Across Code Files​

This function maintains identical behavior across all target platforms (_WIN32, macOS, iOS, Android, and Xbox Durango). It compiles into the same binary instructions without conditional preprocessor branching.


14. setGenericCallback​

Status: ⚪ Untested in Suites  |  🌐 Cross-Platform Uniform

void setGenericCallback(DescribedBase* object, shared_ptr<SyncCallbackDescriptor::GenericFunction> function) const;
PropertyValue
Return Typevoid
Modifiersvirtual const
Source LocationApp/include/reflection/Callback.h:261
SubsystemApp - Reflection System

How it Works Internally​

Executes setGenericCallback within App - Reflection System. Coordinates interactions with setCallback, bind.

  • Control Flow & Execution: Direct sequential execution.
  • Memory Management: Stack-based automatic variable allocation.
  • Concurrency & Thread Safety: Unsynchronized execution (caller must ensure thread-safety if shared).
  • Error Handling & Invariants: Relies on standard return codes and caller validation.
  • State Mutation: Immutable / read-only operation (const member method; does not alter object state).
  • Key Internal Calls: setCallback, bind.
  • External Library Dependencies: Boost C++ Libraries.

How it is Used in Tests​

No dedicated unit test case directly exercises this function by name.

Verification Note

This function is invoked indirectly through higher-level simulation or integration workloads. To add direct test coverage, introduce a test case in App.UnitTest or Base.UnitTest asserting state changes on setGenericCallback.

Behavioral Differences Across Code Files​

This function maintains identical behavior across all target platforms (_WIN32, macOS, iOS, Android, and Xbox Durango). It compiles into the same binary instructions without conditional preprocessor branching.


15. callGeneric​

Status: ⚪ Untested in Suites  |  🌐 Cross-Platform Uniform

result_type callGeneric(shared_ptr<SyncCallbackDescriptor::GenericFunction> function,
typename boost::function_traits<Signature>::arg1_type arg1,
typename boost::function_traits<Signature>::arg2_type arg2,
typename boost::function_traits<Signature>::arg3_type arg3);
PropertyValue
Return Typeresult_type
Modifiersstatic
Source LocationApp/include/reflection/Callback.h:271
SubsystemApp - Reflection System

How it Works Internally​

Executes callGeneric within App - Reflection System. Coordinates interactions with args, Tuple, push_back. Employs dynamic heap allocation via c++ operator new.

  • Control Flow & Execution: Explicit result return.
  • Memory Management: Dynamic heap allocation via C++ operator new; Reference-counted heap object ownership (boost::shared_ptr).
  • Concurrency & Thread Safety: Unsynchronized execution (caller must ensure thread-safety if shared).
  • Error Handling & Invariants: Relies on standard return codes and caller validation.
  • State Mutation: Pure computational logic or modifies passed-in parameters/references.
  • Key Internal Calls: args, Tuple, push_back.

How it is Used in Tests​

No dedicated unit test case directly exercises this function by name.

Verification Note

This function is invoked indirectly through higher-level simulation or integration workloads. To add direct test coverage, introduce a test case in App.UnitTest or Base.UnitTest asserting state changes on callGeneric.

Behavioral Differences Across Code Files​

This function maintains identical behavior across all target platforms (_WIN32, macOS, iOS, Android, and Xbox Durango). It compiles into the same binary instructions without conditional preprocessor branching.


16. setGenericCallback​

Status: ⚪ Untested in Suites  |  🌐 Cross-Platform Uniform

void setGenericCallback(DescribedBase* object, shared_ptr<SyncCallbackDescriptor::GenericFunction> function) const;
PropertyValue
Return Typevoid
Modifiersvirtual const
Source LocationApp/include/reflection/Callback.h:294
SubsystemApp - Reflection System

How it Works Internally​

Executes setGenericCallback within App - Reflection System. Coordinates interactions with setCallback, bind.

  • Control Flow & Execution: Direct sequential execution.
  • Memory Management: Stack-based automatic variable allocation.
  • Concurrency & Thread Safety: Unsynchronized execution (caller must ensure thread-safety if shared).
  • Error Handling & Invariants: Relies on standard return codes and caller validation.
  • State Mutation: Immutable / read-only operation (const member method; does not alter object state).
  • Key Internal Calls: setCallback, bind.
  • External Library Dependencies: Boost C++ Libraries.

How it is Used in Tests​

No dedicated unit test case directly exercises this function by name.

Verification Note

This function is invoked indirectly through higher-level simulation or integration workloads. To add direct test coverage, introduce a test case in App.UnitTest or Base.UnitTest asserting state changes on setGenericCallback.

Behavioral Differences Across Code Files​

This function maintains identical behavior across all target platforms (_WIN32, macOS, iOS, Android, and Xbox Durango). It compiles into the same binary instructions without conditional preprocessor branching.


17. callGeneric​

Status: ⚪ Untested in Suites  |  🌐 Cross-Platform Uniform

result_type callGeneric(shared_ptr<SyncCallbackDescriptor::GenericFunction> function,
typename boost::function_traits<Signature>::arg1_type arg1,
typename boost::function_traits<Signature>::arg2_type arg2,
typename boost::function_traits<Signature>::arg3_type arg3,
typename boost::function_traits<Signature>::arg4_type arg4);
PropertyValue
Return Typeresult_type
Modifiersstatic
Source LocationApp/include/reflection/Callback.h:304
SubsystemApp - Reflection System

How it Works Internally​

Executes callGeneric within App - Reflection System. Coordinates interactions with args, Tuple, push_back. Employs dynamic heap allocation via c++ operator new.

  • Control Flow & Execution: Explicit result return.
  • Memory Management: Dynamic heap allocation via C++ operator new; Reference-counted heap object ownership (boost::shared_ptr).
  • Concurrency & Thread Safety: Unsynchronized execution (caller must ensure thread-safety if shared).
  • Error Handling & Invariants: Relies on standard return codes and caller validation.
  • State Mutation: Pure computational logic or modifies passed-in parameters/references.
  • Key Internal Calls: args, Tuple, push_back.

How it is Used in Tests​

No dedicated unit test case directly exercises this function by name.

Verification Note

This function is invoked indirectly through higher-level simulation or integration workloads. To add direct test coverage, introduce a test case in App.UnitTest or Base.UnitTest asserting state changes on callGeneric.

Behavioral Differences Across Code Files​

This function maintains identical behavior across all target platforms (_WIN32, macOS, iOS, Android, and Xbox Durango). It compiles into the same binary instructions without conditional preprocessor branching.


18. setGenericCallback​

Status: ⚪ Untested in Suites  |  🌐 Cross-Platform Uniform

void setGenericCallback(DescribedBase* object, shared_ptr<SyncCallbackDescriptor::GenericFunction> function) const;
PropertyValue
Return Typevoid
Modifiersvirtual const
Source LocationApp/include/reflection/Callback.h:330
SubsystemApp - Reflection System

How it Works Internally​

Executes setGenericCallback within App - Reflection System. Coordinates interactions with setCallback, bind.

  • Control Flow & Execution: Direct sequential execution.
  • Memory Management: Stack-based automatic variable allocation.
  • Concurrency & Thread Safety: Unsynchronized execution (caller must ensure thread-safety if shared).
  • Error Handling & Invariants: Relies on standard return codes and caller validation.
  • State Mutation: Immutable / read-only operation (const member method; does not alter object state).
  • Key Internal Calls: setCallback, bind.
  • External Library Dependencies: Boost C++ Libraries.

How it is Used in Tests​

No dedicated unit test case directly exercises this function by name.

Verification Note

This function is invoked indirectly through higher-level simulation or integration workloads. To add direct test coverage, introduce a test case in App.UnitTest or Base.UnitTest asserting state changes on setGenericCallback.

Behavioral Differences Across Code Files​

This function maintains identical behavior across all target platforms (_WIN32, macOS, iOS, Android, and Xbox Durango). It compiles into the same binary instructions without conditional preprocessor branching.


19. setCallback​

Status: 🧪 Tested  |  🌐 Cross-Platform Uniform

void setCallback(DescribedBase* object, const Function& value) const;
PropertyValue
Return Typevoid
Modifiersvirtual const
Source LocationApp/include/reflection/Callback.h:350
SubsystemApp - Reflection System

How it Works Internally​

Executes setCallback within App - Reflection System.

  • Control Flow & Execution: Conditional branching.
  • Memory Management: Stack-based automatic variable allocation.
  • Concurrency & Thread Safety: Unsynchronized execution (caller must ensure thread-safety if shared).
  • Error Handling & Invariants: Relies on standard return codes and caller validation.
  • State Mutation: Immutable / read-only operation (const member method; does not alter object state).

How it is Used in Tests​

This function is exercised in 1 test case(s):

  • Reflection::Callbacks (App.UnitTest/ReflectionTest.cpp:135)
    • Usage Pattern: Direct Call
    • Assertions Checked: BOOST_CHECK_EQUAL(test.func0, f0), BOOST_CHECK_EQUAL(test.func1, f1)
    • Callsite Snippet: desc0.setCallback(&test, f0);

Behavioral Differences Across Code Files​

This function maintains identical behavior across all target platforms (_WIN32, macOS, iOS, Android, and Xbox Durango). It compiles into the same binary instructions without conditional preprocessor branching.


20. callGeneric​

Status: ⚪ Untested in Suites  |  🌐 Cross-Platform Uniform

void callGeneric(shared_ptr<AsyncCallbackDescriptor::GenericFunction> function,
AsyncCallbackDescriptor::ResumeFunction resumeFunction, AsyncCallbackDescriptor::ErrorFunction errorFunction);
PropertyValue
Return Typevoid
Modifiersstatic
Source LocationApp/include/reflection/Callback.h:438
SubsystemApp - Reflection System

How it Works Internally​

Executes callGeneric within App - Reflection System. Coordinates interactions with args, Tuple, callGenericImpl. Employs dynamic heap allocation via c++ operator new.

  • Control Flow & Execution: Direct sequential execution.
  • Memory Management: Dynamic heap allocation via C++ operator new; Reference-counted heap object ownership (boost::shared_ptr).
  • Concurrency & Thread Safety: Unsynchronized execution (caller must ensure thread-safety if shared).
  • Error Handling & Invariants: Relies on standard return codes and caller validation.
  • State Mutation: Pure computational logic or modifies passed-in parameters/references.
  • Key Internal Calls: args, Tuple, callGenericImpl.

How it is Used in Tests​

No dedicated unit test case directly exercises this function by name.

Verification Note

This function is invoked indirectly through higher-level simulation or integration workloads. To add direct test coverage, introduce a test case in App.UnitTest or Base.UnitTest asserting state changes on callGeneric.

Behavioral Differences Across Code Files​

This function maintains identical behavior across all target platforms (_WIN32, macOS, iOS, Android, and Xbox Durango). It compiles into the same binary instructions without conditional preprocessor branching.


21. declareSignature​

Status: ⚪ Untested in Suites  |  🌐 Cross-Platform Uniform

void declareSignature();
PropertyValue
Return Typevoid
ModifiersNone
Source LocationApp/include/reflection/Callback.h:445
SubsystemApp - Reflection System

How it Works Internally​

Executes declareSignature within App - Reflection System. Coordinates interactions with BOOST_STATIC_ASSERT.

  • Control Flow & Execution: Direct sequential execution.
  • Memory Management: Stack-based automatic variable allocation.
  • Concurrency & Thread Safety: Unsynchronized execution (caller must ensure thread-safety if shared).
  • Error Handling & Invariants: Relies on standard return codes and caller validation.
  • State Mutation: Pure computational logic or modifies passed-in parameters/references.
  • Key Internal Calls: BOOST_STATIC_ASSERT.
  • External Library Dependencies: Boost C++ Libraries.

How it is Used in Tests​

No dedicated unit test case directly exercises this function by name.

Verification Note

This function is invoked indirectly through higher-level simulation or integration workloads. To add direct test coverage, introduce a test case in App.UnitTest or Base.UnitTest asserting state changes on declareSignature.

Behavioral Differences Across Code Files​

This function maintains identical behavior across all target platforms (_WIN32, macOS, iOS, Android, and Xbox Durango). It compiles into the same binary instructions without conditional preprocessor branching.


22. setGenericCallback​

Status: ⚪ Untested in Suites  |  🌐 Cross-Platform Uniform

void setGenericCallback(DescribedBase* object, shared_ptr<AsyncCallbackDescriptor::GenericFunction> function) const;
PropertyValue
Return Typevoid
Modifiersvirtual const
Source LocationApp/include/reflection/Callback.h:473
SubsystemApp - Reflection System

How it Works Internally​

Executes setGenericCallback within App - Reflection System. Coordinates interactions with setGenericCallbackImpl, bind.

  • Control Flow & Execution: Direct sequential execution.
  • Memory Management: Stack-based automatic variable allocation.
  • Concurrency & Thread Safety: Unsynchronized execution (caller must ensure thread-safety if shared).
  • Error Handling & Invariants: Relies on standard return codes and caller validation.
  • State Mutation: Immutable / read-only operation (const member method; does not alter object state).
  • Key Internal Calls: setGenericCallbackImpl, bind.
  • External Library Dependencies: Boost C++ Libraries.

How it is Used in Tests​

No dedicated unit test case directly exercises this function by name.

Verification Note

This function is invoked indirectly through higher-level simulation or integration workloads. To add direct test coverage, introduce a test case in App.UnitTest or Base.UnitTest asserting state changes on setGenericCallback.

Behavioral Differences Across Code Files​

This function maintains identical behavior across all target platforms (_WIN32, macOS, iOS, Android, and Xbox Durango). It compiles into the same binary instructions without conditional preprocessor branching.


23. clearCallback​

Status: ⚪ Untested in Suites  |  🌐 Cross-Platform Uniform

void clearCallback(DescribedBase* object) const;
PropertyValue
Return Typevoid
Modifiersvirtual const
Source LocationApp/include/reflection/Callback.h:477
SubsystemApp - Reflection System

How it Works Internally​

Executes clearCallback within App - Reflection System. Coordinates interactions with setGenericCallbackImpl, Function.

  • Control Flow & Execution: Direct sequential execution.
  • Memory Management: Stack-based automatic variable allocation.
  • Concurrency & Thread Safety: Unsynchronized execution (caller must ensure thread-safety if shared).
  • Error Handling & Invariants: Relies on standard return codes and caller validation.
  • State Mutation: Immutable / read-only operation (const member method; does not alter object state).
  • Key Internal Calls: setGenericCallbackImpl, Function.

How it is Used in Tests​

No dedicated unit test case directly exercises this function by name.

Verification Note

This function is invoked indirectly through higher-level simulation or integration workloads. To add direct test coverage, introduce a test case in App.UnitTest or Base.UnitTest asserting state changes on clearCallback.

Behavioral Differences Across Code Files​

This function maintains identical behavior across all target platforms (_WIN32, macOS, iOS, Android, and Xbox Durango). It compiles into the same binary instructions without conditional preprocessor branching.


24. callGeneric​

Status: ⚪ Untested in Suites  |  🌐 Cross-Platform Uniform

void callGeneric(shared_ptr<AsyncCallbackDescriptor::GenericFunction> function,
Arg1 arg1,
AsyncCallbackDescriptor::ResumeFunction resumeFunction, AsyncCallbackDescriptor::ErrorFunction errorFunction);
PropertyValue
Return Typevoid
Modifiersstatic
Source LocationApp/include/reflection/Callback.h:489
SubsystemApp - Reflection System

How it Works Internally​

Executes callGeneric within App - Reflection System. Coordinates interactions with args, Tuple, push_back, callGenericImpl. Employs dynamic heap allocation via c++ operator new.

  • Control Flow & Execution: Direct sequential execution.
  • Memory Management: Dynamic heap allocation via C++ operator new; Reference-counted heap object ownership (boost::shared_ptr).
  • Concurrency & Thread Safety: Unsynchronized execution (caller must ensure thread-safety if shared).
  • Error Handling & Invariants: Relies on standard return codes and caller validation.
  • State Mutation: Pure computational logic or modifies passed-in parameters/references.
  • Key Internal Calls: args, Tuple, push_back, callGenericImpl.

How it is Used in Tests​

No dedicated unit test case directly exercises this function by name.

Verification Note

This function is invoked indirectly through higher-level simulation or integration workloads. To add direct test coverage, introduce a test case in App.UnitTest or Base.UnitTest asserting state changes on callGeneric.

Behavioral Differences Across Code Files​

This function maintains identical behavior across all target platforms (_WIN32, macOS, iOS, Android, and Xbox Durango). It compiles into the same binary instructions without conditional preprocessor branching.


25. declareSignature​

Status: ⚪ Untested in Suites  |  🌐 Cross-Platform Uniform

void declareSignature(const char* arg1name);
PropertyValue
Return Typevoid
ModifiersNone
Source LocationApp/include/reflection/Callback.h:498
SubsystemApp - Reflection System

How it Works Internally​

Executes declareSignature within App - Reflection System. Coordinates interactions with BOOST_STATIC_ASSERT, addArgument, declare.

  • Control Flow & Execution: Direct sequential execution.
  • Memory Management: Stack-based automatic variable allocation.
  • Concurrency & Thread Safety: Unsynchronized execution (caller must ensure thread-safety if shared).
  • Error Handling & Invariants: Relies on standard return codes and caller validation.
  • State Mutation: Pure computational logic or modifies passed-in parameters/references.
  • Key Internal Calls: BOOST_STATIC_ASSERT, addArgument, declare.
  • External Library Dependencies: Boost C++ Libraries.

How it is Used in Tests​

No dedicated unit test case directly exercises this function by name.

Verification Note

This function is invoked indirectly through higher-level simulation or integration workloads. To add direct test coverage, introduce a test case in App.UnitTest or Base.UnitTest asserting state changes on declareSignature.

Behavioral Differences Across Code Files​

This function maintains identical behavior across all target platforms (_WIN32, macOS, iOS, Android, and Xbox Durango). It compiles into the same binary instructions without conditional preprocessor branching.


26. setGenericCallback​

Status: ⚪ Untested in Suites  |  🌐 Cross-Platform Uniform

void setGenericCallback(DescribedBase* object, shared_ptr<AsyncCallbackDescriptor::GenericFunction> function) const;
PropertyValue
Return Typevoid
Modifiersvirtual const
Source LocationApp/include/reflection/Callback.h:527
SubsystemApp - Reflection System

How it Works Internally​

Executes setGenericCallback within App - Reflection System. Coordinates interactions with setGenericCallbackImpl, bind.

  • Control Flow & Execution: Direct sequential execution.
  • Memory Management: Stack-based automatic variable allocation.
  • Concurrency & Thread Safety: Unsynchronized execution (caller must ensure thread-safety if shared).
  • Error Handling & Invariants: Relies on standard return codes and caller validation.
  • State Mutation: Immutable / read-only operation (const member method; does not alter object state).
  • Key Internal Calls: setGenericCallbackImpl, bind.
  • External Library Dependencies: Boost C++ Libraries.

How it is Used in Tests​

No dedicated unit test case directly exercises this function by name.

Verification Note

This function is invoked indirectly through higher-level simulation or integration workloads. To add direct test coverage, introduce a test case in App.UnitTest or Base.UnitTest asserting state changes on setGenericCallback.

Behavioral Differences Across Code Files​

This function maintains identical behavior across all target platforms (_WIN32, macOS, iOS, Android, and Xbox Durango). It compiles into the same binary instructions without conditional preprocessor branching.


27. clearCallback​

Status: ⚪ Untested in Suites  |  🌐 Cross-Platform Uniform

void clearCallback(DescribedBase* object) const;
PropertyValue
Return Typevoid
Modifiersvirtual const
Source LocationApp/include/reflection/Callback.h:531
SubsystemApp - Reflection System

How it Works Internally​

Executes clearCallback within App - Reflection System. Coordinates interactions with setGenericCallbackImpl, Function.

  • Control Flow & Execution: Direct sequential execution.
  • Memory Management: Stack-based automatic variable allocation.
  • Concurrency & Thread Safety: Unsynchronized execution (caller must ensure thread-safety if shared).
  • Error Handling & Invariants: Relies on standard return codes and caller validation.
  • State Mutation: Immutable / read-only operation (const member method; does not alter object state).
  • Key Internal Calls: setGenericCallbackImpl, Function.

How it is Used in Tests​

No dedicated unit test case directly exercises this function by name.

Verification Note

This function is invoked indirectly through higher-level simulation or integration workloads. To add direct test coverage, introduce a test case in App.UnitTest or Base.UnitTest asserting state changes on clearCallback.

Behavioral Differences Across Code Files​

This function maintains identical behavior across all target platforms (_WIN32, macOS, iOS, Android, and Xbox Durango). It compiles into the same binary instructions without conditional preprocessor branching.


28. callGeneric​

Status: ⚪ Untested in Suites  |  🌐 Cross-Platform Uniform

void callGeneric(shared_ptr<AsyncCallbackDescriptor::GenericFunction> function,
Arg1 arg1,
Arg2 arg2,
AsyncCallbackDescriptor::ResumeFunction resumeFunction, AsyncCallbackDescriptor::ErrorFunction errorFunction);
PropertyValue
Return Typevoid
Modifiersstatic
Source LocationApp/include/reflection/Callback.h:544
SubsystemApp - Reflection System

How it Works Internally​

Executes callGeneric within App - Reflection System. Coordinates interactions with args, Tuple, push_back, callGenericImpl. Employs dynamic heap allocation via c++ operator new.

  • Control Flow & Execution: Direct sequential execution.
  • Memory Management: Dynamic heap allocation via C++ operator new; Reference-counted heap object ownership (boost::shared_ptr).
  • Concurrency & Thread Safety: Unsynchronized execution (caller must ensure thread-safety if shared).
  • Error Handling & Invariants: Relies on standard return codes and caller validation.
  • State Mutation: Pure computational logic or modifies passed-in parameters/references.
  • Key Internal Calls: args, Tuple, push_back, callGenericImpl.

How it is Used in Tests​

No dedicated unit test case directly exercises this function by name.

Verification Note

This function is invoked indirectly through higher-level simulation or integration workloads. To add direct test coverage, introduce a test case in App.UnitTest or Base.UnitTest asserting state changes on callGeneric.

Behavioral Differences Across Code Files​

This function maintains identical behavior across all target platforms (_WIN32, macOS, iOS, Android, and Xbox Durango). It compiles into the same binary instructions without conditional preprocessor branching.


29. declareSignature​

Status: ⚪ Untested in Suites  |  🌐 Cross-Platform Uniform

void declareSignature(const char* arg1name, const char* arg2name);
PropertyValue
Return Typevoid
ModifiersNone
Source LocationApp/include/reflection/Callback.h:555
SubsystemApp - Reflection System

How it Works Internally​

Executes declareSignature within App - Reflection System. Coordinates interactions with BOOST_STATIC_ASSERT, addArgument, declare.

  • Control Flow & Execution: Direct sequential execution.
  • Memory Management: Stack-based automatic variable allocation.
  • Concurrency & Thread Safety: Unsynchronized execution (caller must ensure thread-safety if shared).
  • Error Handling & Invariants: Relies on standard return codes and caller validation.
  • State Mutation: Pure computational logic or modifies passed-in parameters/references.
  • Key Internal Calls: BOOST_STATIC_ASSERT, addArgument, declare.
  • External Library Dependencies: Boost C++ Libraries.

How it is Used in Tests​

No dedicated unit test case directly exercises this function by name.

Verification Note

This function is invoked indirectly through higher-level simulation or integration workloads. To add direct test coverage, introduce a test case in App.UnitTest or Base.UnitTest asserting state changes on declareSignature.

Behavioral Differences Across Code Files​

This function maintains identical behavior across all target platforms (_WIN32, macOS, iOS, Android, and Xbox Durango). It compiles into the same binary instructions without conditional preprocessor branching.


30. setGenericCallback​

Status: ⚪ Untested in Suites  |  🌐 Cross-Platform Uniform

void setGenericCallback(DescribedBase* object, shared_ptr<AsyncCallbackDescriptor::GenericFunction> function) const;
PropertyValue
Return Typevoid
Modifiersvirtual const
Source LocationApp/include/reflection/Callback.h:585
SubsystemApp - Reflection System

How it Works Internally​

Executes setGenericCallback within App - Reflection System. Coordinates interactions with setGenericCallbackImpl, bind.

  • Control Flow & Execution: Direct sequential execution.
  • Memory Management: Stack-based automatic variable allocation.
  • Concurrency & Thread Safety: Unsynchronized execution (caller must ensure thread-safety if shared).
  • Error Handling & Invariants: Relies on standard return codes and caller validation.
  • State Mutation: Immutable / read-only operation (const member method; does not alter object state).
  • Key Internal Calls: setGenericCallbackImpl, bind.
  • External Library Dependencies: Boost C++ Libraries.

How it is Used in Tests​

No dedicated unit test case directly exercises this function by name.

Verification Note

This function is invoked indirectly through higher-level simulation or integration workloads. To add direct test coverage, introduce a test case in App.UnitTest or Base.UnitTest asserting state changes on setGenericCallback.

Behavioral Differences Across Code Files​

This function maintains identical behavior across all target platforms (_WIN32, macOS, iOS, Android, and Xbox Durango). It compiles into the same binary instructions without conditional preprocessor branching.


31. clearCallback​

Status: ⚪ Untested in Suites  |  🌐 Cross-Platform Uniform

void clearCallback(DescribedBase* object) const;
PropertyValue
Return Typevoid
Modifiersvirtual const
Source LocationApp/include/reflection/Callback.h:589
SubsystemApp - Reflection System

How it Works Internally​

Executes clearCallback within App - Reflection System. Coordinates interactions with setGenericCallbackImpl, Function.

  • Control Flow & Execution: Direct sequential execution.
  • Memory Management: Stack-based automatic variable allocation.
  • Concurrency & Thread Safety: Unsynchronized execution (caller must ensure thread-safety if shared).
  • Error Handling & Invariants: Relies on standard return codes and caller validation.
  • State Mutation: Immutable / read-only operation (const member method; does not alter object state).
  • Key Internal Calls: setGenericCallbackImpl, Function.

How it is Used in Tests​

No dedicated unit test case directly exercises this function by name.

Verification Note

This function is invoked indirectly through higher-level simulation or integration workloads. To add direct test coverage, introduce a test case in App.UnitTest or Base.UnitTest asserting state changes on clearCallback.

Behavioral Differences Across Code Files​

This function maintains identical behavior across all target platforms (_WIN32, macOS, iOS, Android, and Xbox Durango). It compiles into the same binary instructions without conditional preprocessor branching.


32. checkLockedDown​

Status: ⚪ Untested in Suites  |  🌐 Cross-Platform Uniform

void checkLockedDown();
PropertyValue
Return Typevoid
Modifiersstatic
Source LocationApp/include/reflection/Descriptor.h:12
SubsystemApp - Reflection System

How it Works Internally​

Executes checkLockedDown within App - Reflection System. Coordinates interactions with FactoryRegistrator, RBXCRASH.

  • Control Flow & Execution: Conditional branching.
  • Memory Management: Stack-based automatic variable allocation.
  • Concurrency & Thread Safety: Unsynchronized execution (caller must ensure thread-safety if shared).
  • Error Handling & Invariants: Relies on standard return codes and caller validation.
  • State Mutation: Pure computational logic or modifies passed-in parameters/references.
  • Key Internal Calls: FactoryRegistrator, RBXCRASH.

How it is Used in Tests​

No dedicated unit test case directly exercises this function by name.

Verification Note

This function is invoked indirectly through higher-level simulation or integration workloads. To add direct test coverage, introduce a test case in App.UnitTest or Base.UnitTest asserting state changes on checkLockedDown.

Behavioral Differences Across Code Files​

This function maintains identical behavior across all target platforms (_WIN32, macOS, iOS, Android, and Xbox Durango). It compiles into the same binary instructions without conditional preprocessor branching.


33. deprecated​

Status: ⚪ Untested in Suites  |  🌐 Cross-Platform Uniform

Attributes deprecated(const Descriptor& preferred);
PropertyValue
Return TypeAttributes
Modifiersstatic
Source LocationApp/include/reflection/Descriptor.h:30
SubsystemApp - Reflection System

How it Works Internally​

Executes deprecated within App - Reflection System.

  • Control Flow & Execution: Explicit result return.
  • Memory Management: Stack-based automatic variable allocation.
  • Concurrency & Thread Safety: Unsynchronized execution (caller must ensure thread-safety if shared).
  • Error Handling & Invariants: Relies on standard return codes and caller validation.
  • State Mutation: Pure computational logic or modifies passed-in parameters/references.

How it is Used in Tests​

No dedicated unit test case directly exercises this function by name.

Verification Note

This function is invoked indirectly through higher-level simulation or integration workloads. To add direct test coverage, introduce a test case in App.UnitTest or Base.UnitTest asserting state changes on deprecated.

Behavioral Differences Across Code Files​

This function maintains identical behavior across all target platforms (_WIN32, macOS, iOS, Android, and Xbox Durango). It compiles into the same binary instructions without conditional preprocessor branching.


34. deprecated​

Status: ⚪ Untested in Suites  |  🌐 Cross-Platform Uniform

Attributes deprecated();
PropertyValue
Return TypeAttributes
Modifiersstatic
Source LocationApp/include/reflection/Descriptor.h:37
SubsystemApp - Reflection System

How it Works Internally​

Executes deprecated within App - Reflection System.

  • Control Flow & Execution: Explicit result return.
  • Memory Management: Stack-based automatic variable allocation.
  • Concurrency & Thread Safety: Unsynchronized execution (caller must ensure thread-safety if shared).
  • Error Handling & Invariants: Relies on standard return codes and caller validation.
  • State Mutation: Pure computational logic or modifies passed-in parameters/references.

How it is Used in Tests​

No dedicated unit test case directly exercises this function by name.

Verification Note

This function is invoked indirectly through higher-level simulation or integration workloads. To add direct test coverage, introduce a test case in App.UnitTest or Base.UnitTest asserting state changes on deprecated.

Behavioral Differences Across Code Files​

This function maintains identical behavior across all target platforms (_WIN32, macOS, iOS, Android, and Xbox Durango). It compiles into the same binary instructions without conditional preprocessor branching.


35. ~Descriptor​

Status: ⚪ Untested in Suites  |  🌐 Cross-Platform Uniform

virtual ~Descriptor();
PropertyValue
Return Typevirtual
ModifiersNone
Source LocationApp/include/reflection/Descriptor.h:71
SubsystemApp - Reflection System

How it Works Internally​

Declaration or inline method for ~Descriptor.

  • Control Flow & Execution: Linear execution flow.
  • Memory Management: Standard stack allocation.
  • Concurrency & Thread Safety: Unsynchronized / single-threaded context.
  • Error Handling & Invariants: Standard return value verification.
  • State Mutation: Stateless or local modification.

How it is Used in Tests​

No dedicated unit test case directly exercises this function by name.

Verification Note

This function is invoked indirectly through higher-level simulation or integration workloads. To add direct test coverage, introduce a test case in App.UnitTest or Base.UnitTest asserting state changes on ~Descriptor.

Behavioral Differences Across Code Files​

This function maintains identical behavior across all target platforms (_WIN32, macOS, iOS, Android, and Xbox Durango). It compiles into the same binary instructions without conditional preprocessor branching.


36. allEnumSize​

Status: ⚪ Untested in Suites  |  🌐 Cross-Platform Uniform

size_t allEnumSize();
PropertyValue
Return Typesize_t
Modifiersstatic
Source LocationApp/include/reflection/EnumConverter.h:19
SubsystemApp - Reflection System

How it Works Internally​

Executes allEnumSize within App - Reflection System. Coordinates interactions with allEnums, size.

  • Control Flow & Execution: Explicit result return.
  • Memory Management: Stack-based automatic variable allocation.
  • Concurrency & Thread Safety: Unsynchronized execution (caller must ensure thread-safety if shared).
  • Error Handling & Invariants: Relies on standard return codes and caller validation.
  • State Mutation: Pure computational logic or modifies passed-in parameters/references.
  • Key Internal Calls: allEnums, size.

How it is Used in Tests​

No dedicated unit test case directly exercises this function by name.

Verification Note

This function is invoked indirectly through higher-level simulation or integration workloads. To add direct test coverage, introduce a test case in App.UnitTest or Base.UnitTest asserting state changes on allEnumSize.

Behavioral Differences Across Code Files​

This function maintains identical behavior across all target platforms (_WIN32, macOS, iOS, Android, and Xbox Durango). It compiles into the same binary instructions without conditional preprocessor branching.


37. convertToValue​

Status: ⚪ Untested in Suites  |  🌐 Cross-Platform Uniform

bool convertToValue(Variant& value) const;
PropertyValue
Return Typebool
Modifiersconst
Source LocationApp/include/reflection/EnumConverter.h:34
SubsystemApp - Reflection System

How it Works Internally​

Executes convertToValue within App - Reflection System.

  • Control Flow & Execution: Explicit result return.
  • Memory Management: Stack-based automatic variable allocation.
  • Concurrency & Thread Safety: Unsynchronized execution (caller must ensure thread-safety if shared).
  • Error Handling & Invariants: Relies on standard return codes and caller validation.
  • State Mutation: Immutable / read-only operation (const member method; does not alter object state).

How it is Used in Tests​

No dedicated unit test case directly exercises this function by name.

Verification Note

This function is invoked indirectly through higher-level simulation or integration workloads. To add direct test coverage, introduce a test case in App.UnitTest or Base.UnitTest asserting state changes on convertToValue.

Behavioral Differences Across Code Files​

This function maintains identical behavior across all target platforms (_WIN32, macOS, iOS, Android, and Xbox Durango). It compiles into the same binary instructions without conditional preprocessor branching.


38. convertToString​

Status: ⚪ Untested in Suites  |  🌐 Cross-Platform Uniform

bool convertToString(std::string& value) const;
PropertyValue
Return Typebool
Modifiersconst
Source LocationApp/include/reflection/EnumConverter.h:38
SubsystemApp - Reflection System

How it Works Internally​

Executes convertToString within App - Reflection System.

  • Control Flow & Execution: Explicit result return.
  • Memory Management: Stack-based automatic variable allocation.
  • Concurrency & Thread Safety: Unsynchronized execution (caller must ensure thread-safety if shared).
  • Error Handling & Invariants: Relies on standard return codes and caller validation.
  • State Mutation: Immutable / read-only operation (const member method; does not alter object state).

How it is Used in Tests​

No dedicated unit test case directly exercises this function by name.

Verification Note

This function is invoked indirectly through higher-level simulation or integration workloads. To add direct test coverage, introduce a test case in App.UnitTest or Base.UnitTest asserting state changes on convertToString.

Behavioral Differences Across Code Files​

This function maintains identical behavior across all target platforms (_WIN32, macOS, iOS, Android, and Xbox Durango). It compiles into the same binary instructions without conditional preprocessor branching.


39. equalValue​

Status: ⚪ Untested in Suites  |  🌐 Cross-Platform Uniform

bool equalValue(const Item* item, int intValue);
PropertyValue
Return Typebool
Modifiersstatic
Source LocationApp/include/reflection/EnumConverter.h:53
SubsystemApp - Reflection System

How it Works Internally​

Executes equalValue within App - Reflection System.

  • Control Flow & Execution: Explicit result return.
  • Memory Management: Stack-based automatic variable allocation.
  • Concurrency & Thread Safety: Unsynchronized execution (caller must ensure thread-safety if shared).
  • Error Handling & Invariants: Relies on standard return codes and caller validation.
  • State Mutation: Pure computational logic or modifies passed-in parameters/references.

How it is Used in Tests​

No dedicated unit test case directly exercises this function by name.

Verification Note

This function is invoked indirectly through higher-level simulation or integration workloads. To add direct test coverage, introduce a test case in App.UnitTest or Base.UnitTest asserting state changes on equalValue.

Behavioral Differences Across Code Files​

This function maintains identical behavior across all target platforms (_WIN32, macOS, iOS, Android, and Xbox Durango). It compiles into the same binary instructions without conditional preprocessor branching.


40. getEnumCount​

Status: ⚪ Untested in Suites  |  🌐 Cross-Platform Uniform

public:
size_t getEnumCount() const;
PropertyValue
Return Type`public:
size_t`
Modifiersconst
Source LocationApp/include/reflection/EnumConverter.h:66
SubsystemApp - Reflection System

How it Works Internally​

Executes getEnumCount within App - Reflection System.

  • Control Flow & Execution: Explicit result return.
  • Memory Management: Stack-based automatic variable allocation.
  • Concurrency & Thread Safety: Unsynchronized execution (caller must ensure thread-safety if shared).
  • Error Handling & Invariants: Relies on standard return codes and caller validation.
  • State Mutation: Immutable / read-only operation (const member method; does not alter object state).

How it is Used in Tests​

No dedicated unit test case directly exercises this function by name.

Verification Note

This function is invoked indirectly through higher-level simulation or integration workloads. To add direct test coverage, introduce a test case in App.UnitTest or Base.UnitTest asserting state changes on getEnumCount.

Behavioral Differences Across Code Files​

This function maintains identical behavior across all target platforms (_WIN32, macOS, iOS, Android, and Xbox Durango). It compiles into the same binary instructions without conditional preprocessor branching.


41. getEnumCountMSB​

Status: ⚪ Untested in Suites  |  🌐 Cross-Platform Uniform

size_t getEnumCountMSB() const;
PropertyValue
Return Typesize_t
Modifiersconst
Source LocationApp/include/reflection/EnumConverter.h:68
SubsystemApp - Reflection System

How it Works Internally​

Executes getEnumCountMSB within App - Reflection System.

  • Control Flow & Execution: Explicit result return.
  • Memory Management: Stack-based automatic variable allocation.
  • Concurrency & Thread Safety: Unsynchronized execution (caller must ensure thread-safety if shared).
  • Error Handling & Invariants: Relies on standard return codes and caller validation.
  • State Mutation: Immutable / read-only operation (const member method; does not alter object state).

How it is Used in Tests​

No dedicated unit test case directly exercises this function by name.

Verification Note

This function is invoked indirectly through higher-level simulation or integration workloads. To add direct test coverage, introduce a test case in App.UnitTest or Base.UnitTest asserting state changes on getEnumCountMSB.

Behavioral Differences Across Code Files​

This function maintains identical behavior across all target platforms (_WIN32, macOS, iOS, Android, and Xbox Durango). It compiles into the same binary instructions without conditional preprocessor branching.


42. lookupDescriptor​

Status: ⚪ Untested in Suites  |  🌐 Cross-Platform Uniform

EnumDescriptor* lookupDescriptor(const RBX::Name& name) const;
PropertyValue
Return TypeEnumDescriptor*
Modifiersstatic const
Source LocationApp/include/reflection/EnumConverter.h:75
SubsystemApp - Reflection System

How it Works Internally​

Executes lookupDescriptor within App - Reflection System. Coordinates interactions with allEnumsNameLookup, find, end.

  • Control Flow & Execution: Conditional branching, Explicit result return.
  • Memory Management: Stack-based automatic variable allocation.
  • Concurrency & Thread Safety: Unsynchronized execution (caller must ensure thread-safety if shared).
  • Error Handling & Invariants: Relies on standard return codes and caller validation.
  • State Mutation: Immutable / read-only operation (const member method; does not alter object state).
  • Key Internal Calls: allEnumsNameLookup, find, end.

How it is Used in Tests​

No dedicated unit test case directly exercises this function by name.

Verification Note

This function is invoked indirectly through higher-level simulation or integration workloads. To add direct test coverage, introduce a test case in App.UnitTest or Base.UnitTest asserting state changes on lookupDescriptor.

Behavioral Differences Across Code Files​

This function maintains identical behavior across all target platforms (_WIN32, macOS, iOS, Android, and Xbox Durango). It compiles into the same binary instructions without conditional preprocessor branching.


43. lookupDescriptor​

Status: ⚪ Untested in Suites  |  🌐 Cross-Platform Uniform

EnumDescriptor* lookupDescriptor(const Type& type) const;
PropertyValue
Return TypeEnumDescriptor*
Modifiersstatic const
Source LocationApp/include/reflection/EnumConverter.h:82
SubsystemApp - Reflection System

How it Works Internally​

Executes lookupDescriptor within App - Reflection System.

  • Control Flow & Execution: Conditional branching, Explicit result return.
  • Memory Management: Stack-based automatic variable allocation.
  • Concurrency & Thread Safety: Unsynchronized execution (caller must ensure thread-safety if shared).
  • Error Handling & Invariants: Relies on standard return codes and caller validation.
  • State Mutation: Immutable / read-only operation (const member method; does not alter object state).

How it is Used in Tests​

No dedicated unit test case directly exercises this function by name.

Verification Note

This function is invoked indirectly through higher-level simulation or integration workloads. To add direct test coverage, introduce a test case in App.UnitTest or Base.UnitTest asserting state changes on lookupDescriptor.

Behavioral Differences Across Code Files​

This function maintains identical behavior across all target platforms (_WIN32, macOS, iOS, Android, and Xbox Durango). It compiles into the same binary instructions without conditional preprocessor branching.


44. isValue​

Status: ⚪ Untested in Suites  |  🌐 Cross-Platform Uniform

bool isValue(int intValue) const;
PropertyValue
Return Typebool
Modifiersconst
Source LocationApp/include/reflection/EnumConverter.h:88
SubsystemApp - Reflection System

How it Works Internally​

Executes isValue within App - Reflection System. Coordinates interactions with find_if, begin, end, bind.

  • Control Flow & Execution: Explicit result return.
  • Memory Management: Stack-based automatic variable allocation.
  • Concurrency & Thread Safety: Unsynchronized execution (caller must ensure thread-safety if shared).
  • Error Handling & Invariants: Relies on standard return codes and caller validation.
  • State Mutation: Immutable / read-only operation (const member method; does not alter object state).
  • Key Internal Calls: find_if, begin, end, bind.
  • External Library Dependencies: Boost C++ Libraries.

How it is Used in Tests​

No dedicated unit test case directly exercises this function by name.

Verification Note

This function is invoked indirectly through higher-level simulation or integration workloads. To add direct test coverage, introduce a test case in App.UnitTest or Base.UnitTest asserting state changes on isValue.

Behavioral Differences Across Code Files​

This function maintains identical behavior across all target platforms (_WIN32, macOS, iOS, Android, and Xbox Durango). It compiles into the same binary instructions without conditional preprocessor branching.


45. doGetSingleton​

Status: ⚪ Untested in Suites  |  🌐 Cross-Platform Uniform

T& doGetSingleton();
PropertyValue
Return TypeT&
Modifiersstatic
Source LocationApp/include/reflection/EnumConverter.h:102
SubsystemApp - Reflection System

How it Works Internally​

Executes doGetSingleton within App - Reflection System.

  • Control Flow & Execution: Explicit result return.
  • Memory Management: Stack-based automatic variable allocation.
  • Concurrency & Thread Safety: Unsynchronized execution (caller must ensure thread-safety if shared).
  • Error Handling & Invariants: Relies on standard return codes and caller validation.
  • State Mutation: Pure computational logic or modifies passed-in parameters/references.

How it is Used in Tests​

No dedicated unit test case directly exercises this function by name.

Verification Note

This function is invoked indirectly through higher-level simulation or integration workloads. To add direct test coverage, introduce a test case in App.UnitTest or Base.UnitTest asserting state changes on doGetSingleton.

Behavioral Differences Across Code Files​

This function maintains identical behavior across all target platforms (_WIN32, macOS, iOS, Android, and Xbox Durango). It compiles into the same binary instructions without conditional preprocessor branching.


46. initSingleton​

Status: ⚪ Untested in Suites  |  🌐 Cross-Platform Uniform

void initSingleton();
PropertyValue
Return Typevoid
Modifiersstatic
Source LocationApp/include/reflection/EnumConverter.h:107
SubsystemApp - Reflection System

How it Works Internally​

Executes initSingleton within App - Reflection System. Coordinates interactions with doGetSingleton.

  • Control Flow & Execution: Direct sequential execution.
  • Memory Management: Stack-based automatic variable allocation.
  • Concurrency & Thread Safety: Unsynchronized execution (caller must ensure thread-safety if shared).
  • Error Handling & Invariants: Relies on standard return codes and caller validation.
  • State Mutation: Pure computational logic or modifies passed-in parameters/references.
  • Key Internal Calls: doGetSingleton.
  • External Library Dependencies: OpenGL / GLES Graphics API.

How it is Used in Tests​

No dedicated unit test case directly exercises this function by name.

Verification Note

This function is invoked indirectly through higher-level simulation or integration workloads. To add direct test coverage, introduce a test case in App.UnitTest or Base.UnitTest asserting state changes on initSingleton.

Behavioral Differences Across Code Files​

This function maintains identical behavior across all target platforms (_WIN32, macOS, iOS, Android, and Xbox Durango). It compiles into the same binary instructions without conditional preprocessor branching.


47. singleton​

Status: 🧪 Tested  |  ⚠️ Platform Divergent

T& singleton();
PropertyValue
Return TypeT&
Modifiersstatic
Source LocationApp/include/reflection/EnumConverter.h:112
SubsystemApp - Reflection System

How it Works Internally​

Executes singleton within App - Reflection System. Coordinates interactions with call_once, doGetSingleton.

  • Control Flow & Execution: Explicit result return.
  • Memory Management: Stack-based automatic variable allocation.
  • Concurrency & Thread Safety: Unsynchronized execution (caller must ensure thread-safety if shared).
  • Error Handling & Invariants: Relies on standard return codes and caller validation.
  • State Mutation: Pure computational logic or modifies passed-in parameters/references.
  • Key Internal Calls: call_once, doGetSingleton.
  • External Library Dependencies: Boost C++ Libraries, OpenGL / GLES Graphics API.

How it is Used in Tests​

This function is exercised in 9 test case(s):

  • SettingsTest::CanAccessMembersThroughBracketNotationWithoutTriggeringProtection (App.UnitTest/SettingsTest.cpp:68)
    • Usage Pattern: Direct Call
    • Assertions Checked: BOOST_CHECK(result-&gt;at(0).cast&lt;double&gt;() &gt; 0)
    • Callsite Snippet: RBX::TaskSchedulerSettings::singleton();
  • ReplicatorGcJobTest::MovingPartOutsideOfStreamedAreaCausesItToBeGced (App.UnitTest/ReplicatorGcJobTest.cpp:98)
    • Usage Pattern: Performance Benchmark
    • Assertions Checked: BOOST_REQUIRE(clientDm-&gt;getWorkspace()-&gt;findFirstChildByName("BasePlate")), BOOST_REQUIRE(clientDm-&gt;getWorkspace()-&gt;findFirstChildByName("ToStreamOut"))
    • Callsite Snippet: NetworkSettings::singleton().setExtraMemoryUsedInMB(MemoryStats::totalMemoryBytes()/1024/1024);
  • ReplicatorGcJobTest::MovingPartAndItsParentOutsideOfStreamedAreaShouldNotRemoveThePartTwice (App.UnitTest/ReplicatorGcJobTest.cpp:195)
    • Usage Pattern: Performance Benchmark
    • Assertions Checked: BOOST_REQUIRE(clientDm-&gt;getWorkspace()-&gt;findFirstChildByName("BasePlate")), BOOST_REQUIRE(parent)
    • Callsite Snippet: NetworkSettings::singleton().setExtraMemoryUsedInMB(MemoryStats::totalMemoryBytes()/1024/1024);
  • ReplicatorGcJobTest::ReparentingToGcedPartCausesInstanceToLeave (App.UnitTest/ReplicatorGcJobTest.cpp:305)
    • Usage Pattern: Performance Benchmark
    • Assertions Checked: BOOST_REQUIRE(clientDm-&gt;getWorkspace()-&gt;findFirstChildByName("Inside")), BOOST_REQUIRE(clientDm-&gt;getWorkspace()-&gt;findFirstChildByName("Outside"))
    • Callsite Snippet: NetworkSettings::singleton().setExtraMemoryUsedInMB(MemoryStats::totalMemoryBytes()/1024/1024);

Behavioral Differences Across Code Files​

Divergence Analysis: Alternative platform-specific implementations exist in: RobloxStudio/MobileDevelopmentDeployer.cpp.

  • Alternative Implementation Files: RobloxStudio/MobileDevelopmentDeployer.cpp

48. singleton​

Status: 🧪 Tested  |  ⚠️ Platform Divergent

EnumDesc& singleton() const;
PropertyValue
Return TypeEnumDesc&
Modifiersstatic const
Source LocationApp/include/reflection/EnumConverter.h:127
SubsystemApp - Reflection System

How it Works Internally​

Executes singleton within App - Reflection System.

  • Control Flow & Execution: Explicit result return.
  • Memory Management: Stack-based automatic variable allocation.
  • Concurrency & Thread Safety: Unsynchronized execution (caller must ensure thread-safety if shared).
  • Error Handling & Invariants: Relies on standard return codes and caller validation.
  • State Mutation: Immutable / read-only operation (const member method; does not alter object state).
  • External Library Dependencies: OpenGL / GLES Graphics API.

How it is Used in Tests​

This function is exercised in 9 test case(s):

  • SettingsTest::CanAccessMembersThroughBracketNotationWithoutTriggeringProtection (App.UnitTest/SettingsTest.cpp:68)
    • Usage Pattern: Direct Call
    • Assertions Checked: BOOST_CHECK(result-&gt;at(0).cast&lt;double&gt;() &gt; 0)
    • Callsite Snippet: RBX::TaskSchedulerSettings::singleton();
  • ReplicatorGcJobTest::MovingPartOutsideOfStreamedAreaCausesItToBeGced (App.UnitTest/ReplicatorGcJobTest.cpp:98)
    • Usage Pattern: Performance Benchmark
    • Assertions Checked: BOOST_REQUIRE(clientDm-&gt;getWorkspace()-&gt;findFirstChildByName("BasePlate")), BOOST_REQUIRE(clientDm-&gt;getWorkspace()-&gt;findFirstChildByName("ToStreamOut"))
    • Callsite Snippet: NetworkSettings::singleton().setExtraMemoryUsedInMB(MemoryStats::totalMemoryBytes()/1024/1024);
  • ReplicatorGcJobTest::MovingPartAndItsParentOutsideOfStreamedAreaShouldNotRemoveThePartTwice (App.UnitTest/ReplicatorGcJobTest.cpp:195)
    • Usage Pattern: Performance Benchmark
    • Assertions Checked: BOOST_REQUIRE(clientDm-&gt;getWorkspace()-&gt;findFirstChildByName("BasePlate")), BOOST_REQUIRE(parent)
    • Callsite Snippet: NetworkSettings::singleton().setExtraMemoryUsedInMB(MemoryStats::totalMemoryBytes()/1024/1024);
  • ReplicatorGcJobTest::ReparentingToGcedPartCausesInstanceToLeave (App.UnitTest/ReplicatorGcJobTest.cpp:305)
    • Usage Pattern: Performance Benchmark
    • Assertions Checked: BOOST_REQUIRE(clientDm-&gt;getWorkspace()-&gt;findFirstChildByName("Inside")), BOOST_REQUIRE(clientDm-&gt;getWorkspace()-&gt;findFirstChildByName("Outside"))
    • Callsite Snippet: NetworkSettings::singleton().setExtraMemoryUsedInMB(MemoryStats::totalMemoryBytes()/1024/1024);

Behavioral Differences Across Code Files​

Divergence Analysis: Alternative platform-specific implementations exist in: RobloxStudio/MobileDevelopmentDeployer.cpp.

  • Alternative Implementation Files: RobloxStudio/MobileDevelopmentDeployer.cpp

49. addLegacy​

Status: ⚪ Untested in Suites  |  🌐 Cross-Platform Uniform

void addLegacy(int oldValue, const char* name, Enum value);
PropertyValue
Return Typevoid
ModifiersNone
Source LocationApp/include/reflection/EnumConverter.h:200
SubsystemApp - Reflection System

How it Works Internally​

Executes addLegacy within App - Reflection System. Coordinates interactions with RBXASSERT_VERY_FAST, size, resize, declare.

  • Control Flow & Execution: Conditional branching.
  • Memory Management: Stack-based automatic variable allocation.
  • Concurrency & Thread Safety: Unsynchronized execution (caller must ensure thread-safety if shared).
  • Error Handling & Invariants: Relies on standard return codes and caller validation.
  • State Mutation: Pure computational logic or modifies passed-in parameters/references.
  • Key Internal Calls: RBXASSERT_VERY_FAST, size, resize, declare.

How it is Used in Tests​

No dedicated unit test case directly exercises this function by name.

Verification Note

This function is invoked indirectly through higher-level simulation or integration workloads. To add direct test coverage, introduce a test case in App.UnitTest or Base.UnitTest asserting state changes on addLegacy.

Behavioral Differences Across Code Files​

This function maintains identical behavior across all target platforms (_WIN32, macOS, iOS, Android, and Xbox Durango). It compiles into the same binary instructions without conditional preprocessor branching.


50. addLegacyName​

Status: ⚪ Untested in Suites  |  🌐 Cross-Platform Uniform

void addLegacyName(const char* name, Enum value);
PropertyValue
Return Typevoid
ModifiersNone
Source LocationApp/include/reflection/EnumConverter.h:209
SubsystemApp - Reflection System

How it Works Internally​

Executes addLegacyName within App - Reflection System. Coordinates interactions with declare.

  • Control Flow & Execution: Direct sequential execution.
  • Memory Management: Stack-based automatic variable allocation.
  • Concurrency & Thread Safety: Unsynchronized execution (caller must ensure thread-safety if shared).
  • Error Handling & Invariants: Relies on standard return codes and caller validation.
  • State Mutation: Pure computational logic or modifies passed-in parameters/references.
  • Key Internal Calls: declare.

How it is Used in Tests​

No dedicated unit test case directly exercises this function by name.

Verification Note

This function is invoked indirectly through higher-level simulation or integration workloads. To add direct test coverage, introduce a test case in App.UnitTest or Base.UnitTest asserting state changes on addLegacyName.

Behavioral Differences Across Code Files​

This function maintains identical behavior across all target platforms (_WIN32, macOS, iOS, Android, and Xbox Durango). It compiles into the same binary instructions without conditional preprocessor branching.


51. convertToName​

Status: ⚪ Untested in Suites  |  🌐 Cross-Platform Uniform

RBX::Name& convertToName(const Enum& value) const;
PropertyValue
Return TypeRBX::Name&
Modifiersconst const
Source LocationApp/include/reflection/EnumConverter.h:214
SubsystemApp - Reflection System

How it Works Internally​

Executes convertToName within App - Reflection System. Coordinates interactions with RBXASSERT, size, getNullName.

  • Control Flow & Execution: Conditional branching, Explicit result return.
  • Memory Management: Stack-based automatic variable allocation.
  • Concurrency & Thread Safety: Unsynchronized execution (caller must ensure thread-safety if shared).
  • Error Handling & Invariants: Engine invariant assertion check (RBXASSERT).
  • State Mutation: Immutable / read-only operation (const member method; does not alter object state).
  • Key Internal Calls: RBXASSERT, size, getNullName.

How it is Used in Tests​

No dedicated unit test case directly exercises this function by name.

Verification Note

This function is invoked indirectly through higher-level simulation or integration workloads. To add direct test coverage, introduce a test case in App.UnitTest or Base.UnitTest asserting state changes on convertToName.

Behavioral Differences Across Code Files​

This function maintains identical behavior across all target platforms (_WIN32, macOS, iOS, Android, and Xbox Durango). It compiles into the same binary instructions without conditional preprocessor branching.


52. convertToString​

Status: ⚪ Untested in Suites  |  🌐 Cross-Platform Uniform

std::string convertToString(const Enum& value) const;
PropertyValue
Return Typestd::string
Modifiersconst
Source LocationApp/include/reflection/EnumConverter.h:225
SubsystemApp - Reflection System

How it Works Internally​

Executes convertToString within App - Reflection System. Coordinates interactions with RBXASSERT, size.

  • Control Flow & Execution: Conditional branching, Explicit result return.
  • Memory Management: Stack-based automatic variable allocation.
  • Concurrency & Thread Safety: Unsynchronized execution (caller must ensure thread-safety if shared).
  • Error Handling & Invariants: Engine invariant assertion check (RBXASSERT).
  • State Mutation: Immutable / read-only operation (const member method; does not alter object state).
  • Key Internal Calls: RBXASSERT, size.

How it is Used in Tests​

No dedicated unit test case directly exercises this function by name.

Verification Note

This function is invoked indirectly through higher-level simulation or integration workloads. To add direct test coverage, introduce a test case in App.UnitTest or Base.UnitTest asserting state changes on convertToString.

Behavioral Differences Across Code Files​

This function maintains identical behavior across all target platforms (_WIN32, macOS, iOS, Android, and Xbox Durango). It compiles into the same binary instructions without conditional preprocessor branching.


53. convertToItem​

Status: ⚪ Untested in Suites  |  🌐 Cross-Platform Uniform

Item* convertToItem(const Enum& value) const;
PropertyValue
Return TypeItem*
Modifiersconst const
Source LocationApp/include/reflection/EnumConverter.h:236
SubsystemApp - Reflection System

How it Works Internally​

Executes convertToItem within App - Reflection System. Coordinates interactions with RBXASSERT, size.

  • Control Flow & Execution: Conditional branching, Explicit result return.
  • Memory Management: Stack-based automatic variable allocation.
  • Concurrency & Thread Safety: Unsynchronized execution (caller must ensure thread-safety if shared).
  • Error Handling & Invariants: Engine invariant assertion check (RBXASSERT).
  • State Mutation: Immutable / read-only operation (const member method; does not alter object state).
  • Key Internal Calls: RBXASSERT, size.

How it is Used in Tests​

No dedicated unit test case directly exercises this function by name.

Verification Note

This function is invoked indirectly through higher-level simulation or integration workloads. To add direct test coverage, introduce a test case in App.UnitTest or Base.UnitTest asserting state changes on convertToItem.

Behavioral Differences Across Code Files​

This function maintains identical behavior across all target platforms (_WIN32, macOS, iOS, Android, and Xbox Durango). It compiles into the same binary instructions without conditional preprocessor branching.


54. mapIntValue​

Status: ⚪ Untested in Suites  |  🌐 Cross-Platform Uniform

bool mapIntValue(int intValue, Enum& value) const;
PropertyValue
Return Typebool
Modifiersconst
Source LocationApp/include/reflection/EnumConverter.h:247
SubsystemApp - Reflection System

How it Works Internally​

Executes mapIntValue within App - Reflection System. Coordinates interactions with size.

  • Control Flow & Execution: Conditional branching, Explicit result return.
  • Memory Management: Stack-based automatic variable allocation.
  • Concurrency & Thread Safety: Unsynchronized execution (caller must ensure thread-safety if shared).
  • Error Handling & Invariants: Relies on standard return codes and caller validation.
  • State Mutation: Immutable / read-only operation (const member method; does not alter object state).
  • Key Internal Calls: size.

How it is Used in Tests​

No dedicated unit test case directly exercises this function by name.

Verification Note

This function is invoked indirectly through higher-level simulation or integration workloads. To add direct test coverage, introduce a test case in App.UnitTest or Base.UnitTest asserting state changes on mapIntValue.

Behavioral Differences Across Code Files​

This function maintains identical behavior across all target platforms (_WIN32, macOS, iOS, Android, and Xbox Durango). It compiles into the same binary instructions without conditional preprocessor branching.


55. convertToValue​

Status: ⚪ Untested in Suites  |  🌐 Cross-Platform Uniform

bool convertToValue(const RBX::Name& name, Enum& value) const;
PropertyValue
Return Typebool
Modifiersconst
Source LocationApp/include/reflection/EnumConverter.h:261
SubsystemApp - Reflection System

How it Works Internally​

Executes convertToValue within App - Reflection System. Coordinates interactions with find, end.

  • Control Flow & Execution: Conditional branching, Explicit result return.
  • Memory Management: Stack-based automatic variable allocation.
  • Concurrency & Thread Safety: Unsynchronized execution (caller must ensure thread-safety if shared).
  • Error Handling & Invariants: Relies on standard return codes and caller validation.
  • State Mutation: Immutable / read-only operation (const member method; does not alter object state).
  • Key Internal Calls: find, end.

How it is Used in Tests​

No dedicated unit test case directly exercises this function by name.

Verification Note

This function is invoked indirectly through higher-level simulation or integration workloads. To add direct test coverage, introduce a test case in App.UnitTest or Base.UnitTest asserting state changes on convertToValue.

Behavioral Differences Across Code Files​

This function maintains identical behavior across all target platforms (_WIN32, macOS, iOS, Android, and Xbox Durango). It compiles into the same binary instructions without conditional preprocessor branching.


56. convertToValue​

Status: ⚪ Untested in Suites  |  🌐 Cross-Platform Uniform

bool convertToValue(const char* text, Enum& value) const;
PropertyValue
Return Typebool
Modifiersconst
Source LocationApp/include/reflection/EnumConverter.h:307
SubsystemApp - Reflection System

How it Works Internally​

Executes convertToValue within App - Reflection System. Coordinates interactions with lookup.

  • Control Flow & Execution: Explicit result return.
  • Memory Management: Stack-based automatic variable allocation.
  • Concurrency & Thread Safety: Unsynchronized execution (caller must ensure thread-safety if shared).
  • Error Handling & Invariants: Relies on standard return codes and caller validation.
  • State Mutation: Immutable / read-only operation (const member method; does not alter object state).
  • Key Internal Calls: lookup.

How it is Used in Tests​

No dedicated unit test case directly exercises this function by name.

Verification Note

This function is invoked indirectly through higher-level simulation or integration workloads. To add direct test coverage, introduce a test case in App.UnitTest or Base.UnitTest asserting state changes on convertToValue.

Behavioral Differences Across Code Files​

This function maintains identical behavior across all target platforms (_WIN32, macOS, iOS, Android, and Xbox Durango). It compiles into the same binary instructions without conditional preprocessor branching.


57. convertToIndex​

Status: ⚪ Untested in Suites  |  🌐 Cross-Platform Uniform

size_t convertToIndex(Enum value) const;
PropertyValue
Return Typesize_t
Modifiersconst
Source LocationApp/include/reflection/EnumConverter.h:313
SubsystemApp - Reflection System

How it Works Internally​

Executes convertToIndex within App - Reflection System. Coordinates interactions with RBXASSERT, size.

  • Control Flow & Execution: Conditional branching, Explicit result return.
  • Memory Management: Stack-based automatic variable allocation.
  • Concurrency & Thread Safety: Unsynchronized execution (caller must ensure thread-safety if shared).
  • Error Handling & Invariants: Engine invariant assertion check (RBXASSERT).
  • State Mutation: Immutable / read-only operation (const member method; does not alter object state).
  • Key Internal Calls: RBXASSERT, size.

How it is Used in Tests​

No dedicated unit test case directly exercises this function by name.

Verification Note

This function is invoked indirectly through higher-level simulation or integration workloads. To add direct test coverage, introduce a test case in App.UnitTest or Base.UnitTest asserting state changes on convertToIndex.

Behavioral Differences Across Code Files​

This function maintains identical behavior across all target platforms (_WIN32, macOS, iOS, Android, and Xbox Durango). It compiles into the same binary instructions without conditional preprocessor branching.


58. convertToValue​

Status: ⚪ Untested in Suites  |  🌐 Cross-Platform Uniform

bool convertToValue(size_t index, Enum& value) const;
PropertyValue
Return Typebool
Modifiersconst
Source LocationApp/include/reflection/EnumConverter.h:321
SubsystemApp - Reflection System

How it Works Internally​

Executes convertToValue within App - Reflection System.

  • Control Flow & Execution: Conditional branching, Explicit result return.
  • Memory Management: Stack-based automatic variable allocation.
  • Concurrency & Thread Safety: Unsynchronized execution (caller must ensure thread-safety if shared).
  • Error Handling & Invariants: Relies on standard return codes and caller validation.
  • State Mutation: Immutable / read-only operation (const member method; does not alter object state).

How it is Used in Tests​

No dedicated unit test case directly exercises this function by name.

Verification Note

This function is invoked indirectly through higher-level simulation or integration workloads. To add direct test coverage, introduce a test case in App.UnitTest or Base.UnitTest asserting state changes on convertToValue.

Behavioral Differences Across Code Files​

This function maintains identical behavior across all target platforms (_WIN32, macOS, iOS, Android, and Xbox Durango). It compiles into the same binary instructions without conditional preprocessor branching.


59. dummy​

Status: 🧪 Tested  |  🌐 Cross-Platform Uniform

public:
void dummy();
PropertyValue
Return Type`public:
void`
ModifiersNone
Source LocationApp/include/reflection/EnumConverter.h:359
SubsystemApp - Reflection System

How it Works Internally​

Executes dummy within App - Reflection System.

  • Control Flow & Execution: Direct sequential execution.
  • Memory Management: Stack-based automatic variable allocation.
  • Concurrency & Thread Safety: Unsynchronized execution (caller must ensure thread-safety if shared).
  • Error Handling & Invariants: Relies on standard return codes and caller validation.
  • State Mutation: Pure computational logic or modifies passed-in parameters/references.

How it is Used in Tests​

This function is exercised in 2 test case(s):

  • G3D::TestColor3 (App.UnitTest/G3D.cpp:64)
    • Usage Pattern: Direct Assertion
    • Assertions Checked: BOOST_CHECK_EQUAL(color.max(dummy), Color3(0.7f,0.4f,0.8f)), BOOST_CHECK_EQUAL(color.min(dummy), Color3(0.2f,0.2f,0.5f)), BOOST_CHECK_EQUAL(color.fuzzyEq(dummy), false)
    • Callsite Snippet: Color3 dummy(0.7f, 0.2f, 0.5f);
  • G3D::TestCoordinateFrame (App.UnitTest/G3D.cpp:110)
    • Usage Pattern: Direct Assertion
    • Assertions Checked: BOOST_CHECK_EQUAL(coord.fuzzyEq(dummy), false)
    • Callsite Snippet: G3D::CoordinateFrame dummy(normalIdToMatrix3(RBX::NORM_X_NEG), Vector3(0.5, 0.5, 0));

Behavioral Differences Across Code Files​

This function maintains identical behavior across all target platforms (_WIN32, macOS, iOS, Android, and Xbox Durango). It compiles into the same binary instructions without conditional preprocessor branching.


60. ~GenericSlotWrapper​

Status: ⚪ Untested in Suites  |  🌐 Cross-Platform Uniform

public:
virtual ~GenericSlotWrapper();
PropertyValue
Return Type`public:
virtual`
ModifiersNone
Source LocationApp/include/reflection/Event.h:48
SubsystemApp - Reflection System

How it Works Internally​

TODO: make members private/protected as much as possible

  • Control Flow & Execution: Linear execution flow.
  • Memory Management: Standard stack allocation.
  • Concurrency & Thread Safety: Unsynchronized / single-threaded context.
  • Error Handling & Invariants: Standard return value verification.
  • State Mutation: Stateless or local modification.

How it is Used in Tests​

No dedicated unit test case directly exercises this function by name.

Verification Note

This function is invoked indirectly through higher-level simulation or integration workloads. To add direct test coverage, introduce a test case in App.UnitTest or Base.UnitTest asserting state changes on ~GenericSlotWrapper.

Behavioral Differences Across Code Files​

This function maintains identical behavior across all target platforms (_WIN32, macOS, iOS, Android, and Xbox Durango). It compiles into the same binary instructions without conditional preprocessor branching.


Additional Functions

There are 320 additional internal and inline functions in this subsystem. All functions are indexed and cross-referenced in the Complete Function Catalog.