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 File | Path |
|---|---|
Callback.h | App/include/reflection/Callback.h |
Descriptor.h | App/include/reflection/Descriptor.h |
EnumConverter.h | App/include/reflection/EnumConverter.h |
Event.h | App/include/reflection/Event.h |
Function.h | App/include/reflection/Function.h |
Object.h | App/include/reflection/Object.h |
Property.h | App/include/reflection/Property.h |
Type.h | App/include/reflection/Type.h |
YieldFunction.h | App/include/reflection/YieldFunction.h |
member.h | App/include/reflection/member.h |
reflection.h | App/include/reflection/reflection.h |
Callback.cpp | App/reflection/Callback.cpp |
Event.cpp | App/reflection/Event.cpp |
reflection_object.cpp | App/reflection/reflection_object.cpp |
reflection_property.cpp | App/reflection/reflection_property.cpp |
type.cpp | App/reflection/type.cpp |
Function Reference
1. getSignature
Status: ⚪ Untested in Suites | 🌐 Cross-Platform Uniform
SignatureDescriptor& getSignature() const;
| Property | Value |
|---|---|
| Return Type | SignatureDescriptor& |
| Modifiers | inline const const |
| Source Location | App/include/reflection/Callback.h:29 |
| Subsystem | App - 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.
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;
| Property | Value |
|---|---|
| Return Type | bool |
| Modifiers | const |
| Source Location | App/include/reflection/Callback.h:30 |
| Subsystem | App - 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.
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;
| Property | Value |
|---|---|
| Return Type | RBX::Name& |
| Modifiers | inline const const |
| Source Location | App/include/reflection/Callback.h:102 |
| Subsystem | App - 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");
- Usage Pattern:
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");
- Usage Pattern:
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());
- Usage Pattern:
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");
- Usage Pattern:
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;
| Property | Value |
|---|---|
| Return Type | DescribedBase* |
| Modifiers | inline const |
| Source Location | App/include/reflection/Callback.h:106 |
| Subsystem | App - 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.
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;
| Property | Value |
|---|---|
| Return Type | CallbackDescriptor& |
| Modifiers | inline const const |
| Source Location | App/include/reflection/Callback.h:111 |
| Subsystem | App - 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);
- Usage Pattern:
Instance::PerfIsA(App.UnitTest/InstanceTest.cpp:38)- Usage Pattern:
Performance Benchmark - Callsite Snippet:
inst->getDescriptor().isA(RBX::PartInstance::classDescriptor());
- Usage Pattern:
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();
| Property | Value |
|---|---|
| Return Type | `public: |
| virtual` | |
| Modifiers | None |
| Source Location | App/include/reflection/Callback.h:161 |
| Subsystem | App - 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.
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;
| Property | Value |
|---|---|
| Return Type | `public: |
| void` | |
| Modifiers | const |
| Source Location | App/include/reflection/Callback.h:170 |
| Subsystem | App - 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);
- Usage Pattern:
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;
| Property | Value |
|---|---|
| Return Type | void |
| Modifiers | const |
| Source Location | App/include/reflection/Callback.h:175 |
| Subsystem | App - 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.
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);
| Property | Value |
|---|---|
| Return Type | result_type |
| Modifiers | static |
| Source Location | App/include/reflection/Callback.h:189 |
| Subsystem | App - 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.
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;
| Property | Value |
|---|---|
| Return Type | void |
| Modifiers | virtual const |
| Source Location | App/include/reflection/Callback.h:203 |
| Subsystem | App - 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.
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);
| Property | Value |
|---|---|
| Return Type | result_type |
| Modifiers | static |
| Source Location | App/include/reflection/Callback.h:213 |
| Subsystem | App - 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.
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;
| Property | Value |
|---|---|
| Return Type | void |
| Modifiers | virtual const |
| Source Location | App/include/reflection/Callback.h:231 |
| Subsystem | App - 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.
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);
| Property | Value |
|---|---|
| Return Type | result_type |
| Modifiers | static |
| Source Location | App/include/reflection/Callback.h:241 |
| Subsystem | App - 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.
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;
| Property | Value |
|---|---|
| Return Type | void |
| Modifiers | virtual const |
| Source Location | App/include/reflection/Callback.h:261 |
| Subsystem | App - 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.
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);
| Property | Value |
|---|---|
| Return Type | result_type |
| Modifiers | static |
| Source Location | App/include/reflection/Callback.h:271 |
| Subsystem | App - 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.
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;
| Property | Value |
|---|---|
| Return Type | void |
| Modifiers | virtual const |
| Source Location | App/include/reflection/Callback.h:294 |
| Subsystem | App - 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.
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);
| Property | Value |
|---|---|
| Return Type | result_type |
| Modifiers | static |
| Source Location | App/include/reflection/Callback.h:304 |
| Subsystem | App - 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.
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;
| Property | Value |
|---|---|
| Return Type | void |
| Modifiers | virtual const |
| Source Location | App/include/reflection/Callback.h:330 |
| Subsystem | App - 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.
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;
| Property | Value |
|---|---|
| Return Type | void |
| Modifiers | virtual const |
| Source Location | App/include/reflection/Callback.h:350 |
| Subsystem | App - 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);
- Usage Pattern:
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);
| Property | Value |
|---|---|
| Return Type | void |
| Modifiers | static |
| Source Location | App/include/reflection/Callback.h:438 |
| Subsystem | App - 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.
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();
| Property | Value |
|---|---|
| Return Type | void |
| Modifiers | None |
| Source Location | App/include/reflection/Callback.h:445 |
| Subsystem | App - 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.
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;
| Property | Value |
|---|---|
| Return Type | void |
| Modifiers | virtual const |
| Source Location | App/include/reflection/Callback.h:473 |
| Subsystem | App - 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.
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;
| Property | Value |
|---|---|
| Return Type | void |
| Modifiers | virtual const |
| Source Location | App/include/reflection/Callback.h:477 |
| Subsystem | App - 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.
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);
| Property | Value |
|---|---|
| Return Type | void |
| Modifiers | static |
| Source Location | App/include/reflection/Callback.h:489 |
| Subsystem | App - 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.
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);
| Property | Value |
|---|---|
| Return Type | void |
| Modifiers | None |
| Source Location | App/include/reflection/Callback.h:498 |
| Subsystem | App - 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.
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;
| Property | Value |
|---|---|
| Return Type | void |
| Modifiers | virtual const |
| Source Location | App/include/reflection/Callback.h:527 |
| Subsystem | App - 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.
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;
| Property | Value |
|---|---|
| Return Type | void |
| Modifiers | virtual const |
| Source Location | App/include/reflection/Callback.h:531 |
| Subsystem | App - 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.
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);
| Property | Value |
|---|---|
| Return Type | void |
| Modifiers | static |
| Source Location | App/include/reflection/Callback.h:544 |
| Subsystem | App - 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.
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);
| Property | Value |
|---|---|
| Return Type | void |
| Modifiers | None |
| Source Location | App/include/reflection/Callback.h:555 |
| Subsystem | App - 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.
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;
| Property | Value |
|---|---|
| Return Type | void |
| Modifiers | virtual const |
| Source Location | App/include/reflection/Callback.h:585 |
| Subsystem | App - 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.
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;
| Property | Value |
|---|---|
| Return Type | void |
| Modifiers | virtual const |
| Source Location | App/include/reflection/Callback.h:589 |
| Subsystem | App - 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.
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();
| Property | Value |
|---|---|
| Return Type | void |
| Modifiers | static |
| Source Location | App/include/reflection/Descriptor.h:12 |
| Subsystem | App - 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.
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);
| Property | Value |
|---|---|
| Return Type | Attributes |
| Modifiers | static |
| Source Location | App/include/reflection/Descriptor.h:30 |
| Subsystem | App - 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.
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();
| Property | Value |
|---|---|
| Return Type | Attributes |
| Modifiers | static |
| Source Location | App/include/reflection/Descriptor.h:37 |
| Subsystem | App - 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.
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();
| Property | Value |
|---|---|
| Return Type | virtual |
| Modifiers | None |
| Source Location | App/include/reflection/Descriptor.h:71 |
| Subsystem | App - 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.
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();
| Property | Value |
|---|---|
| Return Type | size_t |
| Modifiers | static |
| Source Location | App/include/reflection/EnumConverter.h:19 |
| Subsystem | App - 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.
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;
| Property | Value |
|---|---|
| Return Type | bool |
| Modifiers | const |
| Source Location | App/include/reflection/EnumConverter.h:34 |
| Subsystem | App - 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.
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;
| Property | Value |
|---|---|
| Return Type | bool |
| Modifiers | const |
| Source Location | App/include/reflection/EnumConverter.h:38 |
| Subsystem | App - 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.
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);
| Property | Value |
|---|---|
| Return Type | bool |
| Modifiers | static |
| Source Location | App/include/reflection/EnumConverter.h:53 |
| Subsystem | App - 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.
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;
| Property | Value |
|---|---|
| Return Type | `public: |
| size_t` | |
| Modifiers | const |
| Source Location | App/include/reflection/EnumConverter.h:66 |
| Subsystem | App - 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.
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;
| Property | Value |
|---|---|
| Return Type | size_t |
| Modifiers | const |
| Source Location | App/include/reflection/EnumConverter.h:68 |
| Subsystem | App - 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.
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;
| Property | Value |
|---|---|
| Return Type | EnumDescriptor* |
| Modifiers | static const |
| Source Location | App/include/reflection/EnumConverter.h:75 |
| Subsystem | App - 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.
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;
| Property | Value |
|---|---|
| Return Type | EnumDescriptor* |
| Modifiers | static const |
| Source Location | App/include/reflection/EnumConverter.h:82 |
| Subsystem | App - 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.
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;
| Property | Value |
|---|---|
| Return Type | bool |
| Modifiers | const |
| Source Location | App/include/reflection/EnumConverter.h:88 |
| Subsystem | App - 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.
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();
| Property | Value |
|---|---|
| Return Type | T& |
| Modifiers | static |
| Source Location | App/include/reflection/EnumConverter.h:102 |
| Subsystem | App - 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.
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();
| Property | Value |
|---|---|
| Return Type | void |
| Modifiers | static |
| Source Location | App/include/reflection/EnumConverter.h:107 |
| Subsystem | App - 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.
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();
| Property | Value |
|---|---|
| Return Type | T& |
| Modifiers | static |
| Source Location | App/include/reflection/EnumConverter.h:112 |
| Subsystem | App - 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->at(0).cast<double>() > 0) - Callsite Snippet:
RBX::TaskSchedulerSettings::singleton();
- Usage Pattern:
ReplicatorGcJobTest::MovingPartOutsideOfStreamedAreaCausesItToBeGced(App.UnitTest/ReplicatorGcJobTest.cpp:98)- Usage Pattern:
Performance Benchmark - Assertions Checked:
BOOST_REQUIRE(clientDm->getWorkspace()->findFirstChildByName("BasePlate")),BOOST_REQUIRE(clientDm->getWorkspace()->findFirstChildByName("ToStreamOut")) - Callsite Snippet:
NetworkSettings::singleton().setExtraMemoryUsedInMB(MemoryStats::totalMemoryBytes()/1024/1024);
- Usage Pattern:
ReplicatorGcJobTest::MovingPartAndItsParentOutsideOfStreamedAreaShouldNotRemoveThePartTwice(App.UnitTest/ReplicatorGcJobTest.cpp:195)- Usage Pattern:
Performance Benchmark - Assertions Checked:
BOOST_REQUIRE(clientDm->getWorkspace()->findFirstChildByName("BasePlate")),BOOST_REQUIRE(parent) - Callsite Snippet:
NetworkSettings::singleton().setExtraMemoryUsedInMB(MemoryStats::totalMemoryBytes()/1024/1024);
- Usage Pattern:
ReplicatorGcJobTest::ReparentingToGcedPartCausesInstanceToLeave(App.UnitTest/ReplicatorGcJobTest.cpp:305)- Usage Pattern:
Performance Benchmark - Assertions Checked:
BOOST_REQUIRE(clientDm->getWorkspace()->findFirstChildByName("Inside")),BOOST_REQUIRE(clientDm->getWorkspace()->findFirstChildByName("Outside")) - Callsite Snippet:
NetworkSettings::singleton().setExtraMemoryUsedInMB(MemoryStats::totalMemoryBytes()/1024/1024);
- Usage Pattern:
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;
| Property | Value |
|---|---|
| Return Type | EnumDesc& |
| Modifiers | static const |
| Source Location | App/include/reflection/EnumConverter.h:127 |
| Subsystem | App - 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->at(0).cast<double>() > 0) - Callsite Snippet:
RBX::TaskSchedulerSettings::singleton();
- Usage Pattern:
ReplicatorGcJobTest::MovingPartOutsideOfStreamedAreaCausesItToBeGced(App.UnitTest/ReplicatorGcJobTest.cpp:98)- Usage Pattern:
Performance Benchmark - Assertions Checked:
BOOST_REQUIRE(clientDm->getWorkspace()->findFirstChildByName("BasePlate")),BOOST_REQUIRE(clientDm->getWorkspace()->findFirstChildByName("ToStreamOut")) - Callsite Snippet:
NetworkSettings::singleton().setExtraMemoryUsedInMB(MemoryStats::totalMemoryBytes()/1024/1024);
- Usage Pattern:
ReplicatorGcJobTest::MovingPartAndItsParentOutsideOfStreamedAreaShouldNotRemoveThePartTwice(App.UnitTest/ReplicatorGcJobTest.cpp:195)- Usage Pattern:
Performance Benchmark - Assertions Checked:
BOOST_REQUIRE(clientDm->getWorkspace()->findFirstChildByName("BasePlate")),BOOST_REQUIRE(parent) - Callsite Snippet:
NetworkSettings::singleton().setExtraMemoryUsedInMB(MemoryStats::totalMemoryBytes()/1024/1024);
- Usage Pattern:
ReplicatorGcJobTest::ReparentingToGcedPartCausesInstanceToLeave(App.UnitTest/ReplicatorGcJobTest.cpp:305)- Usage Pattern:
Performance Benchmark - Assertions Checked:
BOOST_REQUIRE(clientDm->getWorkspace()->findFirstChildByName("Inside")),BOOST_REQUIRE(clientDm->getWorkspace()->findFirstChildByName("Outside")) - Callsite Snippet:
NetworkSettings::singleton().setExtraMemoryUsedInMB(MemoryStats::totalMemoryBytes()/1024/1024);
- Usage Pattern:
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);
| Property | Value |
|---|---|
| Return Type | void |
| Modifiers | None |
| Source Location | App/include/reflection/EnumConverter.h:200 |
| Subsystem | App - 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.
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);
| Property | Value |
|---|---|
| Return Type | void |
| Modifiers | None |
| Source Location | App/include/reflection/EnumConverter.h:209 |
| Subsystem | App - 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.
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;
| Property | Value |
|---|---|
| Return Type | RBX::Name& |
| Modifiers | const const |
| Source Location | App/include/reflection/EnumConverter.h:214 |
| Subsystem | App - 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.
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;
| Property | Value |
|---|---|
| Return Type | std::string |
| Modifiers | const |
| Source Location | App/include/reflection/EnumConverter.h:225 |
| Subsystem | App - 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.
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;
| Property | Value |
|---|---|
| Return Type | Item* |
| Modifiers | const const |
| Source Location | App/include/reflection/EnumConverter.h:236 |
| Subsystem | App - 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.
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;
| Property | Value |
|---|---|
| Return Type | bool |
| Modifiers | const |
| Source Location | App/include/reflection/EnumConverter.h:247 |
| Subsystem | App - 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.
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;
| Property | Value |
|---|---|
| Return Type | bool |
| Modifiers | const |
| Source Location | App/include/reflection/EnumConverter.h:261 |
| Subsystem | App - 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.
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;
| Property | Value |
|---|---|
| Return Type | bool |
| Modifiers | const |
| Source Location | App/include/reflection/EnumConverter.h:307 |
| Subsystem | App - 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.
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;
| Property | Value |
|---|---|
| Return Type | size_t |
| Modifiers | const |
| Source Location | App/include/reflection/EnumConverter.h:313 |
| Subsystem | App - 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.
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;
| Property | Value |
|---|---|
| Return Type | bool |
| Modifiers | const |
| Source Location | App/include/reflection/EnumConverter.h:321 |
| Subsystem | App - 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.
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();
| Property | Value |
|---|---|
| Return Type | `public: |
| void` | |
| Modifiers | None |
| Source Location | App/include/reflection/EnumConverter.h:359 |
| Subsystem | App - 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);
- Usage Pattern:
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));
- Usage Pattern:
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();
| Property | Value |
|---|---|
| Return Type | `public: |
| virtual` | |
| Modifiers | None |
| Source Location | App/include/reflection/Event.h:48 |
| Subsystem | App - 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.
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.
There are 320 additional internal and inline functions in this subsystem. All functions are indexed and cross-referenced in the Complete Function Catalog.