Skip to main content

App - Instance Tree

Instance tree, RootInstance, ServiceProvider, and reflection bindings.

Subsystem Metrics​

  • Total Documented Functions: 208
  • Functions Exercised in Tests: 41
  • Platform-Divergent Implementations: 21
  • Component Source Files: 9

Source Files​

View all 9 source files in this subsystem
Source FilePath
Instance.hApp/include/v8tree/Instance.h
Property.hApp/include/v8tree/Property.h
Service.hApp/include/v8tree/Service.h
Verb.hApp/include/v8tree/Verb.h
EnumProperty.cppApp/v8tree/EnumProperty.cpp
Instance.cppApp/v8tree/Instance.cpp
Property.cppApp/v8tree/Property.cpp
Service.cppApp/v8tree/Service.cpp
Verb.cppApp/v8tree/Verb.cpp

Function Reference​

1. DescribedCreatable​

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

protected:
inline DescribedCreatable();
PropertyValue
Return Type`protected:
inline`
ModifiersNone
Source LocationApp/include/v8tree/Instance.h:37
SubsystemApp - Instance Tree

How it Works Internally​

Declaration or inline method for DescribedCreatable.

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

How it is Used in Tests​

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

Verification Note

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

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. DescribedNonCreatable​

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

protected:
inline DescribedNonCreatable();
PropertyValue
Return Type`protected:
inline`
ModifiersNone
Source LocationApp/include/v8tree/Instance.h:55
SubsystemApp - Instance Tree

How it Works Internally​

Declaration or inline method for DescribedNonCreatable.

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

How it is Used in Tests​

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

Verification Note

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

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. ~OnDemandInstance​

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

virtual ~OnDemandInstance();
PropertyValue
Return Typevirtual
ModifiersNone
Source LocationApp/include/v8tree/Instance.h:145
SubsystemApp - Instance Tree

How it Works Internally​

Declaration or inline method for ~OnDemandInstance.

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

How it is Used in Tests​

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

Verification Note

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

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.


4. lockParent​

Status: 🧪 Tested  |  🌐 Cross-Platform Uniform

void lockParent();
PropertyValue
Return Typevoid
ModifiersNone
Source LocationApp/include/v8tree/Instance.h:187
SubsystemApp - Instance Tree

How it Works Internally​

Executes lockParent within App - Instance Tree.

  • 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 1 test case(s):

  • Instance::ReparentingLock (App.UnitTest/Instance.cpp:213)
    • Usage Pattern: Direct Call
    • Assertions Checked: BOOST_CHECK(!parent->getIsParentLocked()), BOOST_CHECK(parent->getIsParentLocked())
    • Callsite Snippet: child->unlockParent();

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. unlockParent​

Status: 🧪 Tested  |  🌐 Cross-Platform Uniform

void unlockParent();
PropertyValue
Return Typevoid
ModifiersNone
Source LocationApp/include/v8tree/Instance.h:189
SubsystemApp - Instance Tree

How it Works Internally​

Executes unlockParent within App - Instance Tree.

  • 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):

  • Instance::ReparentingLock (App.UnitTest/Instance.cpp:213)
    • Usage Pattern: Direct Call
    • Assertions Checked: BOOST_CHECK(!parent->getIsParentLocked()), BOOST_CHECK(parent->getIsParentLocked())
    • Callsite Snippet: child->unlockParent();
  • SettingsTest::AddingSelectionWithPartChildDoesNukeSettings (App.UnitTest/SettingsTest.cpp:234)
    • Usage Pattern: Direct Call
    • Assertions Checked: BOOST_CHECK(errored)
    • Callsite Snippet: sel->unlockParent();

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. getIsParentLocked​

Status: 🧪 Tested  |  🌐 Cross-Platform Uniform

bool getIsParentLocked() const;
PropertyValue
Return Typebool
Modifiersconst
Source LocationApp/include/v8tree/Instance.h:190
SubsystemApp - Instance Tree

How it Works Internally​

Executes getIsParentLocked within App - Instance Tree.

  • 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 1 test case(s):

  • Instance::ReparentingLock (App.UnitTest/Instance.cpp:213)
    • Usage Pattern: Direct Assertion
    • Assertions Checked: BOOST_CHECK(!parent->getIsParentLocked()), BOOST_CHECK(parent->getIsParentLocked()), BOOST_CHECK(child->getIsParentLocked()), BOOST_CHECK(!child->getIsParentLocked())
    • Callsite Snippet: BOOST_CHECK(!parent->getIsParentLocked());

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. getIsArchivable​

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

bool getIsArchivable() const;
PropertyValue
Return Typebool
Modifiersconst
Source LocationApp/include/v8tree/Instance.h:195
SubsystemApp - Instance Tree

How it Works Internally​

Executes getIsArchivable within App - Instance Tree.

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

How it is Used in Tests​

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

Verification Note

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

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. ~ICombinedSignalData​

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

public:
virtual ~ICombinedSignalData();
PropertyValue
Return Type`public:
virtual`
ModifiersNone
Source LocationApp/include/v8tree/Instance.h:228
SubsystemApp - Instance Tree

How it Works Internally​

Declaration or inline method for ~ICombinedSignalData.

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

How it is Used in Tests​

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

Verification Note

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

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. child​

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

: child(child);
PropertyValue
Return Type:
ModifiersNone
Source LocationApp/include/v8tree/Instance.h:236
SubsystemApp - Instance Tree

How it Works Internally​

Declaration or inline method for child.

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

How it is Used in Tests​

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

Verification Note

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

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. child​

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

: child(child);
PropertyValue
Return Type:
ModifiersNone
Source LocationApp/include/v8tree/Instance.h:245
SubsystemApp - Instance Tree

How it Works Internally​

Declaration or inline method for child.

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

How it is Used in Tests​

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

Verification Note

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

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. OutfitChangedSignalData​

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

public: OutfitChangedSignalData();
PropertyValue
Return Typepublic:
ModifiersNone
Source LocationApp/include/v8tree/Instance.h:263
SubsystemApp - Instance Tree

How it Works Internally​

Declaration or inline method for OutfitChangedSignalData.

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

How it is Used in Tests​

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

Verification Note

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

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. HumanoidChangedSignalData​

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

public: HumanoidChangedSignalData();
PropertyValue
Return Typepublic:
ModifiersNone
Source LocationApp/include/v8tree/Instance.h:292
SubsystemApp - Instance Tree

How it Works Internally​

Declaration or inline method for HumanoidChangedSignalData.

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

How it is Used in Tests​

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

Verification Note

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

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. childAddedSignal​

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

void childAddedSignal(shared_ptr<Instance>& inst);
PropertyValue
Return Typevoid
ModifiersNone
Source LocationApp/include/v8tree/Instance.h:298
SubsystemApp - Instance Tree

How it Works Internally​

Executes childAddedSignal within App - Instance Tree. Coordinates interactions with onDemandRead, onDemandWrite.

  • 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: onDemandRead, onDemandWrite.

How it is Used in Tests​

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

Verification Note

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

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. childRemovedSignal​

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

void childRemovedSignal(shared_ptr<Instance>& inst);
PropertyValue
Return Typevoid
ModifiersNone
Source LocationApp/include/v8tree/Instance.h:302
SubsystemApp - Instance Tree

How it Works Internally​

Executes childRemovedSignal within App - Instance Tree. Coordinates interactions with onDemandRead, onDemandWrite.

  • 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: onDemandRead, onDemandWrite.

How it is Used in Tests​

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

Verification Note

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

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. descendantAddedSignal​

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

void descendantAddedSignal(shared_ptr<Instance>& inst);
PropertyValue
Return Typevoid
ModifiersNone
Source LocationApp/include/v8tree/Instance.h:305
SubsystemApp - Instance Tree

How it Works Internally​

Executes descendantAddedSignal within App - Instance Tree. Coordinates interactions with onDemandRead, onDemandWrite.

  • 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: onDemandRead, onDemandWrite.

How it is Used in Tests​

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

Verification Note

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

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. descendantRemovingSignal​

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

void descendantRemovingSignal(const shared_ptr<Instance>& inst);
PropertyValue
Return Typevoid
ModifiersNone
Source LocationApp/include/v8tree/Instance.h:308
SubsystemApp - Instance Tree

How it Works Internally​

Executes descendantRemovingSignal within App - Instance Tree. Coordinates interactions with onDemandRead, onDemandWrite.

  • 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: onDemandRead, onDemandWrite.

How it is Used in Tests​

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

Verification Note

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

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. getClassNameStr​

Status: 🧪 Tested  |  🌐 Cross-Platform Uniform

std::string& getClassNameStr() const;
PropertyValue
Return Typestd::string&
Modifiersconst const
Source LocationApp/include/v8tree/Instance.h:327
SubsystemApp - Instance Tree

How it Works Internally​

Executes getClassNameStr within App - Instance Tree. Coordinates interactions with getClassName, toString.

  • 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: getClassName, toString.

How it is Used in Tests​

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

  • PostEffectTest::BlurEffectDefaults (App.UnitTest/PostEffectTest.cpp:13)
    • Usage Pattern: Direct Assertion
    • Assertions Checked: BOOST_CHECK_EQUAL(effect-&gt;getClassNameStr(), "BlurEffect")
    • Callsite Snippet: BOOST_CHECK_EQUAL(effect-&gt;getClassNameStr(), "BlurEffect");

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. getReadableDebugId​

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

std::string getReadableDebugId(int scopeLength) const;
PropertyValue
Return Typestd::string
Modifiersconst
Source LocationApp/include/v8tree/Instance.h:329
SubsystemApp - Instance Tree

How it Works Internally​

Executes getReadableDebugId within App - Instance Tree. Coordinates interactions with getGuid, readableString.

  • 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: getGuid, readableString.

How it is Used in Tests​

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

Verification Note

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

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. getReadableDebugId​

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

std::string getReadableDebugId() const;
PropertyValue
Return Typestd::string
Modifiersconst
Source LocationApp/include/v8tree/Instance.h:331
SubsystemApp - Instance Tree

How it Works Internally​

Executes getReadableDebugId within App - Instance Tree. Coordinates interactions with getGuid, readableString.

  • 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: getGuid, readableString.

How it is Used in Tests​

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

Verification Note

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

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. getReadableDebugId​

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

std::string getReadableDebugId(int scopeLength);
PropertyValue
Return Typestd::string
ModifiersNone
Source LocationApp/include/v8tree/Instance.h:332
SubsystemApp - Instance Tree

How it Works Internally​

Executes getReadableDebugId within App - Instance Tree. Coordinates interactions with getGuid, readableString.

  • 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: getGuid, readableString.

How it is Used in Tests​

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

Verification Note

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

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. getParent​

Status: 🧪 Tested  |  🌐 Cross-Platform Uniform

Instance* getParent();
PropertyValue
Return TypeInstance*
Modifiersinline
Source LocationApp/include/v8tree/Instance.h:339
SubsystemApp - Instance Tree

How it Works Internally​

Executes getParent within App - Instance Tree.

  • 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​

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

  • Instance::Parenting (App.UnitTest/Instance.cpp:193)
    • Usage Pattern: Direct Assertion
    • Assertions Checked: BOOST_CHECK(checkAncestor-&gt;getParent() != NULL)
    • Callsite Snippet: BOOST_CHECK(checkAncestor-&gt;getParent() != NULL);
  • Instance::ReparentingLock (App.UnitTest/Instance.cpp:213)
    • Usage Pattern: Direct Assertion
    • Assertions Checked: BOOST_CHECK(child-&gt;getParent() == parent.get())
    • Callsite Snippet: BOOST_CHECK(child-&gt;getParent() == parent.get());
  • Instance::WaitForChildOutsideOfDataModel (App.UnitTest/Instance.cpp:525)
    • Usage Pattern: Direct Assertion
    • Assertions Checked: BOOST_REQUIRE(part-&gt;getParent() == NULL)
    • Callsite Snippet: BOOST_REQUIRE(part-&gt;getParent() == NULL);
  • SettingsTest::SelectionDoesNotNukeSettings (App.UnitTest/SettingsTest.cpp:191)
    • Usage Pattern: Direct Assertion
    • Assertions Checked: BOOST_CHECK(sel-&gt;getParent() == settings.get())
    • Callsite Snippet: BOOST_CHECK(sel-&gt;getParent() == settings.get());

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. getParent​

Status: 🧪 Tested  |  🌐 Cross-Platform Uniform

Instance* getParent() const;
PropertyValue
Return TypeInstance*
Modifiersinline const const
Source LocationApp/include/v8tree/Instance.h:341
SubsystemApp - Instance Tree

How it Works Internally​

Executes getParent within App - Instance Tree.

  • 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 8 test case(s):

  • Instance::Parenting (App.UnitTest/Instance.cpp:193)
    • Usage Pattern: Direct Assertion
    • Assertions Checked: BOOST_CHECK(checkAncestor-&gt;getParent() != NULL)
    • Callsite Snippet: BOOST_CHECK(checkAncestor-&gt;getParent() != NULL);
  • Instance::ReparentingLock (App.UnitTest/Instance.cpp:213)
    • Usage Pattern: Direct Assertion
    • Assertions Checked: BOOST_CHECK(child-&gt;getParent() == parent.get())
    • Callsite Snippet: BOOST_CHECK(child-&gt;getParent() == parent.get());
  • Instance::WaitForChildOutsideOfDataModel (App.UnitTest/Instance.cpp:525)
    • Usage Pattern: Direct Assertion
    • Assertions Checked: BOOST_REQUIRE(part-&gt;getParent() == NULL)
    • Callsite Snippet: BOOST_REQUIRE(part-&gt;getParent() == NULL);
  • SettingsTest::SelectionDoesNotNukeSettings (App.UnitTest/SettingsTest.cpp:191)
    • Usage Pattern: Direct Assertion
    • Assertions Checked: BOOST_CHECK(sel-&gt;getParent() == settings.get())
    • Callsite Snippet: BOOST_CHECK(sel-&gt;getParent() == settings.get());

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. getParentDangerous​

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

Instance* getParentDangerous() const;
PropertyValue
Return TypeInstance*
Modifiersinline const
Source LocationApp/include/v8tree/Instance.h:343
SubsystemApp - Instance Tree

How it Works Internally​

Executes getParentDangerous within App - Instance Tree.

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

How it is Used in Tests​

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

Verification Note

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

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. getRootAncestor​

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

Instance* getRootAncestor();
PropertyValue
Return TypeInstance*
Modifiersinline
Source LocationApp/include/v8tree/Instance.h:346
SubsystemApp - Instance Tree

How it Works Internally​

Executes getRootAncestor within App - Instance Tree.

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

How it is Used in Tests​

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

Verification Note

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

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. getRootAncestor​

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

Instance* getRootAncestor() const;
PropertyValue
Return TypeInstance*
Modifiersinline const const
Source LocationApp/include/v8tree/Instance.h:347
SubsystemApp - Instance Tree

How it Works Internally​

Executes getRootAncestor within App - Instance Tree.

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

How it is Used in Tests​

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

Verification Note

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

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. getRootAncestor​

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

Instance* getRootAncestor(Instance* instance);
PropertyValue
Return TypeInstance*
Modifiersstatic
Source LocationApp/include/v8tree/Instance.h:348
SubsystemApp - Instance Tree

How it Works Internally​

Executes getRootAncestor within App - Instance Tree.

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

How it is Used in Tests​

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

Verification Note

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

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. getRootAncestor​

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

Instance* getRootAncestor(const Instance* instance) const;
PropertyValue
Return TypeInstance*
Modifiersstatic const
Source LocationApp/include/v8tree/Instance.h:350
SubsystemApp - Instance Tree

How it Works Internally​

Executes getRootAncestor within App - Instance Tree.

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

How it is Used in Tests​

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

Verification Note

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

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. getRobloxLocked​

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

bool getRobloxLocked() const;
PropertyValue
Return Typebool
Modifiersconst
Source LocationApp/include/v8tree/Instance.h:351
SubsystemApp - Instance Tree

How it Works Internally​

Executes getRobloxLocked within App - Instance Tree.

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

How it is Used in Tests​

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

Verification Note

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

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. setParent​

Status: 🧪 Tested  |  🌐 Cross-Platform Uniform

void setParent(Instance* instance);
PropertyValue
Return Typevoid
ModifiersNone
Source LocationApp/include/v8tree/Instance.h:356
SubsystemApp - Instance Tree

How it Works Internally​

Executes setParent within App - Instance Tree. Coordinates interactions with setParentInternal.

  • 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: setParentInternal.

How it is Used in Tests​

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

  • Instance::Parenting (App.UnitTest/Instance.cpp:193)
    • Usage Pattern: Direct Assertion
    • Assertions Checked: BOOST_CHECK_THROW(instance-&gt;setParent2(dm.dataModel), std::exception), BOOST_CHECK_THROW(checkAncestor-&gt;setParent2(dm.dataModel), std::exception), BOOST_CHECK_THROW(checkAncestor-&gt;setParent2(instance), std::exception)
    • Callsite Snippet: checkAncestor-&gt;setParent2(instance);
  • Instance::ReparentingLock (App.UnitTest/Instance.cpp:213)
    • Usage Pattern: Direct Call
    • Assertions Checked: BOOST_CHECK(!parent-&gt;getIsParentLocked()), BOOST_CHECK(parent-&gt;getIsParentLocked())
    • Callsite Snippet: child-&gt;setParent(NULL);
  • Instance::SetParentNull (App.UnitTest/Instance.cpp:251)
    • Usage Pattern: Direct Call
    • Callsite Snippet: child-&gt;setParent(parent.get());
  • Instance::WaitForChildReturnsImmediatelyIfChildPresent (App.UnitTest/Instance.cpp:264)
    • Usage Pattern: Direct Call
    • Assertions Checked: BOOST_CHECK_EQUAL(part-&gt;getName(), "Renamed")
    • Callsite Snippet: script-&gt;setParent(dm-&gt;getWorkspace());

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. setLockedParent​

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

bool setLockedParent(Instance* instance);
PropertyValue
Return Typebool
ModifiersNone
Source LocationApp/include/v8tree/Instance.h:358
SubsystemApp - Instance Tree

How it Works Internally​

Executes setLockedParent within App - Instance Tree. Coordinates interactions with setParentInternal.

  • 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: setParentInternal.

How it is Used in Tests​

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

Verification Note

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

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. setParent2​

Status: 🧪 Tested  |  🌐 Cross-Platform Uniform

void setParent2(shared_ptr<Instance> instance);
PropertyValue
Return Typevoid
ModifiersNone
Source LocationApp/include/v8tree/Instance.h:359
SubsystemApp - Instance Tree

How it Works Internally​

Executes setParent2 within App - Instance Tree. Coordinates interactions with setParent, get.

  • 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: setParent, get.

How it is Used in Tests​

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

  • Instance::Parenting (App.UnitTest/Instance.cpp:193)
    • Usage Pattern: Direct Assertion
    • Assertions Checked: BOOST_CHECK_THROW(instance-&gt;setParent2(dm.dataModel), std::exception), BOOST_CHECK_THROW(checkAncestor-&gt;setParent2(dm.dataModel), std::exception), BOOST_CHECK_THROW(checkAncestor-&gt;setParent2(instance), std::exception)
    • Callsite Snippet: checkAncestor-&gt;setParent2(instance);

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. getName​

Status: 🧪 Tested  |  ⚠️ Platform Divergent

std::string& getName() const;
PropertyValue
Return Typestd::string&
Modifiersconst const
Source LocationApp/include/v8tree/Instance.h:369
SubsystemApp - Instance Tree

How it Works Internally​

Executes getName within App - Instance Tree. Coordinates interactions with get.

  • 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: get.

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-&gt;getName(), "Renamed")
    • Callsite Snippet: BOOST_CHECK_EQUAL(part-&gt;getName(), "Renamed");
  • Instance::WaitForSameChildAfterInitialWaitForChild (App.UnitTest/Instance.cpp:289)
    • Usage Pattern: Direct Assertion
    • Assertions Checked: BOOST_CHECK_EQUAL(part-&gt;getName(), "Renamed")
    • Callsite Snippet: BOOST_CHECK_EQUAL(part-&gt;getName(), "Renamed");
  • Instance::TwoScriptsWaitingForSameChildRenameOnResume (App.UnitTest/Instance.cpp:356)
    • Usage Pattern: Direct Assertion
    • Assertions Checked: BOOST_CHECK_EQUAL("PartBx", part-&gt;getName()), BOOST_CHECK_EQUAL("PartA", part2-&gt;getName())
    • Callsite Snippet: BOOST_CHECK_EQUAL("PartBx", part-&gt;getName());
  • Instance::WaitForDifferentChildAfterInitialWaitForChild (App.UnitTest/Instance.cpp:478)
    • Usage Pattern: Direct Assertion
    • Assertions Checked: BOOST_CHECK_EQUAL(part-&gt;getName(), "Phase1"), BOOST_CHECK_EQUAL(part-&gt;getName(), "Phase2")
    • Callsite Snippet: BOOST_CHECK_EQUAL(part-&gt;getName(), "Phase1");

Behavioral Differences Across Code Files​

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

  • Alternative Implementation Files: RobloxStudio/RobloxRibbonMainWindow.cpp

33. getFullNameForReflection​

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

std::string getFullNameForReflection();
PropertyValue
Return Typestd::string
ModifiersNone
Source LocationApp/include/v8tree/Instance.h:374
SubsystemApp - Instance Tree

How it Works Internally​

Executes getFullNameForReflection within App - Instance Tree. Coordinates interactions with getFullName.

  • 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: getFullName.

How it is Used in Tests​

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

Verification Note

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

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. isAncestorOf​

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

bool isAncestorOf(const Instance* descendant) const;
PropertyValue
Return Typebool
Modifiersconst
Source LocationApp/include/v8tree/Instance.h:375
SubsystemApp - Instance Tree

How it Works Internally​

Executes isAncestorOf within App - Instance Tree. Coordinates interactions with getParent.

  • 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: getParent.

How it is Used in Tests​

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

Verification Note

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

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. isAncestorOf2​

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

bool isAncestorOf2(shared_ptr<Instance> descendant);
PropertyValue
Return Typebool
ModifiersNone
Source LocationApp/include/v8tree/Instance.h:385
SubsystemApp - Instance Tree

How it Works Internally​

Executes isAncestorOf2 within App - Instance Tree. Coordinates interactions with isAncestorOf, get.

  • 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: isAncestorOf, get.

How it is Used in Tests​

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

Verification Note

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

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. isDescendantOf2​

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

bool isDescendantOf2(shared_ptr<Instance> ancestor);
PropertyValue
Return Typebool
ModifiersNone
Source LocationApp/include/v8tree/Instance.h:387
SubsystemApp - Instance Tree

How it Works Internally​

Executes isDescendantOf2 within App - Instance Tree. Coordinates interactions with isDescendantOf, get.

  • 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: isDescendantOf, get.

How it is Used in Tests​

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

Verification Note

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

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. isDescendantOf​

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

bool isDescendantOf(const Instance* ancestor) const;
PropertyValue
Return Typebool
Modifiersconst
Source LocationApp/include/v8tree/Instance.h:390
SubsystemApp - Instance Tree

How it Works Internally​

isDescendantOf will return true if parent==NULL (consistent with the fact that a top-level Instance has parent==NULL)

  • 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: getParent.

How it is Used in Tests​

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

Verification Note

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

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. findFirstAncestorOfType​

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

Type* findFirstAncestorOfType();
PropertyValue
Return TypeType*
ModifiersNone
Source LocationApp/include/v8tree/Instance.h:400
SubsystemApp - Instance Tree

How it Works Internally​

Executes findFirstAncestorOfType within App - Instance Tree. Coordinates interactions with getParent.

  • 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: Pure computational logic or modifies passed-in parameters/references.
  • Key Internal Calls: getParent.

How it is Used in Tests​

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

Verification Note

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

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. numChildren​

Status: 🧪 Tested  |  🌐 Cross-Platform Uniform

size_t numChildren() const;
PropertyValue
Return Typesize_t
Modifiersconst
Source LocationApp/include/v8tree/Instance.h:412
SubsystemApp - Instance Tree

How it Works Internally​

Executes numChildren within App - Instance Tree. Coordinates interactions with 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: Immutable / read-only operation (const member method; does not alter object state).
  • Key Internal Calls: size.

How it is Used in Tests​

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

  • ChatTests::ReportAbuse (App.UnitTest/ChatTests.cpp:353)
    • Usage Pattern: Direct Call
    • Assertions Checked: BOOST_CHECK(event-&gt;Wait(RBX::Time::Interval::from_seconds(10)))
    • Callsite Snippet: if (players-&gt;numChildren() == 1)
  • SelectionTest::LayerCollectorResetOnSpawn (App.UnitTest/SelectionTest.cpp:64)
    • Usage Pattern: Direct Call
    • Assertions Checked: BOOST_REQUIRE(gui), BOOST_CHECK(persistent-&gt;getResetOnSpawn())
    • Callsite Snippet: BOOST_CHECK_EQUAL(gui-&gt;numChildren(), 2u);

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. computeStringCost​

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

int computeStringCost(const std::string& value);
PropertyValue
Return Typeint
Modifiersstatic
Source LocationApp/include/v8tree/Instance.h:417
SubsystemApp - Instance Tree

How it Works Internally​

Executes computeStringCost within App - Instance Tree. Coordinates interactions with length.

  • 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: length.

How it is Used in Tests​

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

Verification Note

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

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. getChild​

Status: 🧪 Tested  |  🌐 Cross-Platform Uniform

Instance* getChild(size_t index);
PropertyValue
Return TypeInstance*
ModifiersNone
Source LocationApp/include/v8tree/Instance.h:421
SubsystemApp - Instance Tree

How it Works Internally​

Executes getChild within App - Instance Tree. Coordinates interactions with return, get.

  • 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: return, get.

How it is Used in Tests​

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

  • Instance::SetParentNull (App.UnitTest/Instance.cpp:251)
    • Usage Pattern: Direct Call
    • Callsite Snippet: RBX::Instance* child = parent-&gt;getChild(0);
  • ChatTests::ReportAbuse (App.UnitTest/ChatTests.cpp:353)
    • Usage Pattern: Direct Call
    • Assertions Checked: BOOST_CHECK(event-&gt;Wait(RBX::Time::Interval::from_seconds(10)))
    • Callsite Snippet: Player* player = boost::polymorphic_downcast&lt;Player*&gt;(players-&gt;getChild(0));
  • NetworkSecurity::SecurePlayerReplication (App.UnitTest/NetworkSecurity.cpp:186)
    • Usage Pattern: Direct Call
    • Assertions Checked: BOOST_REQUIRE(player), BOOST_REQUIRE(players)
    • Callsite Snippet: RBX::Network::Player* player = Instance::fastDynamicCast&lt;RBX::Network::Player&gt;(players-&gt;getChild(0));

Behavioral Differences Across Code Files​

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


42. getChild​

Status: 🧪 Tested  |  🌐 Cross-Platform Uniform

Instance* getChild(size_t index) const;
PropertyValue
Return TypeInstance*
Modifiersconst const
Source LocationApp/include/v8tree/Instance.h:424
SubsystemApp - Instance Tree

How it Works Internally​

Executes getChild within App - Instance Tree. Coordinates interactions with return, get.

  • 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: return, get.

How it is Used in Tests​

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

  • Instance::SetParentNull (App.UnitTest/Instance.cpp:251)
    • Usage Pattern: Direct Call
    • Callsite Snippet: RBX::Instance* child = parent-&gt;getChild(0);
  • ChatTests::ReportAbuse (App.UnitTest/ChatTests.cpp:353)
    • Usage Pattern: Direct Call
    • Assertions Checked: BOOST_CHECK(event-&gt;Wait(RBX::Time::Interval::from_seconds(10)))
    • Callsite Snippet: Player* player = boost::polymorphic_downcast&lt;Player*&gt;(players-&gt;getChild(0));
  • NetworkSecurity::SecurePlayerReplication (App.UnitTest/NetworkSecurity.cpp:186)
    • Usage Pattern: Direct Call
    • Assertions Checked: BOOST_REQUIRE(player), BOOST_REQUIRE(players)
    • Callsite Snippet: RBX::Network::Player* player = Instance::fastDynamicCast&lt;RBX::Network::Player&gt;(players-&gt;getChild(0));

Behavioral Differences Across Code Files​

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


43. findFirstChildByName​

Status: 🧪 Tested  |  🌐 Cross-Platform Uniform

Instance* findFirstChildByName(const std::string& findName);
PropertyValue
Return TypeInstance*
ModifiersNone
Source LocationApp/include/v8tree/Instance.h:435
SubsystemApp - Instance Tree

How it Works Internally​

Executes findFirstChildByName within App - Instance Tree. Coordinates interactions with findConstFirstChildByName.

  • 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: findConstFirstChildByName.

How it is Used in Tests​

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

  • Instance::TwoScriptsWaitingForSameChild (App.UnitTest/Instance.cpp:314)
    • Usage Pattern: Direct Assertion
    • Assertions Checked: BOOST_CHECK(dm-&gt;getWorkspace()-&gt;findFirstChildByName("Alice") != NULL), BOOST_CHECK(dm-&gt;getWorkspace()-&gt;findFirstChildByName("Bob") != NULL)
    • Callsite Snippet: BOOST_CHECK(dm-&gt;getWorkspace()-&gt;findFirstChildByName("Alice") != NULL);
  • Instance::TwoScriptsWaitingForDifferentChildren (App.UnitTest/Instance.cpp:414)
    • Usage Pattern: Direct Assertion
    • Assertions Checked: BOOST_CHECK(dm-&gt;getWorkspace()-&gt;findFirstChildByName("Alice") == NULL), BOOST_CHECK(dm-&gt;getWorkspace()-&gt;findFirstChildByName("AliceX") != NULL), BOOST_CHECK(dm-&gt;getWorkspace()-&gt;findFirstChildByName("Bob") == NULL), BOOST_CHECK(dm-&gt;getWorkspace()-&gt;findFirstChildByName("BobX") == NULL), BOOST_CHECK(dm-&gt;getWorkspace()-&gt;findFirstChildByName("Alice") == NULL)
    • Callsite Snippet: BOOST_CHECK(dm-&gt;getWorkspace()-&gt;findFirstChildByName("Alice") == NULL);
  • WebSerializer::TestInstanceClone (App.UnitTest/WebSerializerTest.cpp:135)
    • Usage Pattern: Direct Call
    • Assertions Checked: BOOST_CHECK(cloneModel), BOOST_CHECK(clonePart0)
    • Callsite Snippet: Instance* clonePart0 = cloneModel-&gt;findFirstChildByName("Part0");
  • RemoteSignals::RemoteEvent (App.UnitTest/RemoteSignal.cpp:108)
    • Usage Pattern: Direct Call
    • Assertions Checked: BOOST_CHECK(clientTest != 0), BOOST_MESSAGE("Test Client to Server")
    • Callsite Snippet: clientTest = shared_from_static_cast&lt;RemoteEventClass&gt;(clientDm-&gt;getWorkspace()-&gt;findFirstChildByName("Test"));

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. findFirstChildByNameDangerous​

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

Instance* findFirstChildByNameDangerous(const std::string& findName) const;
PropertyValue
Return TypeInstance*
Modifiersconst
Source LocationApp/include/v8tree/Instance.h:438
SubsystemApp - Instance Tree

How it Works Internally​

Executes findFirstChildByNameDangerous within App - Instance Tree. Coordinates interactions with findConstFirstChildByName.

  • 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: findConstFirstChildByName.

How it is Used in Tests​

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

Verification Note

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

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. findFirstChildByName2​

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

shared_ptr<Instance> findFirstChildByName2(std::string findName, bool recursive);
PropertyValue
Return Typeshared_ptr&lt;Instance&gt;
ModifiersNone
Source LocationApp/include/v8tree/Instance.h:446
SubsystemApp - Instance Tree

How it Works Internally​

Used for Reflection:

  • 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: shared_from, findFirstChildByNameRecursive, findFirstChildByName.

How it is Used in Tests​

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

Verification Note

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

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. queryTypedChild​

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

Type* queryTypedChild(int index);
PropertyValue
Return TypeType*
ModifiersNone
Source LocationApp/include/v8tree/Instance.h:451
SubsystemApp - Instance Tree

How it Works Internally​

queryTypedChild

  • 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: get.

How it is Used in Tests​

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

Verification Note

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

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. queryTypedChild​

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

Type* queryTypedChild(int index) const;
PropertyValue
Return TypeType*
Modifiersconst const
Source LocationApp/include/v8tree/Instance.h:455
SubsystemApp - Instance Tree

How it Works Internally​

Executes queryTypedChild within App - Instance Tree. Coordinates interactions with get.

  • 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: get.

How it is Used in Tests​

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

Verification Note

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

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.


48. getTypedChild​

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

Type* getTypedChild(int index);
PropertyValue
Return TypeType*
ModifiersNone
Source LocationApp/include/v8tree/Instance.h:461
SubsystemApp - Instance Tree

How it Works Internally​

getTypedChild

  • 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: get.

How it is Used in Tests​

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

Verification Note

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

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.


49. getTypedChild​

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

Type* getTypedChild(int index) const;
PropertyValue
Return TypeType*
Modifiersconst const
Source LocationApp/include/v8tree/Instance.h:465
SubsystemApp - Instance Tree

How it Works Internally​

Executes getTypedChild within App - Instance Tree. Coordinates interactions with get.

  • 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: get.

How it is Used in Tests​

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

Verification Note

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

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. queryTypedParent​

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

Type* queryTypedParent();
PropertyValue
Return TypeType*
ModifiersNone
Source LocationApp/include/v8tree/Instance.h:472
SubsystemApp - Instance Tree

How it Works Internally​

queryTypedParent

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

How it is Used in Tests​

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

Verification Note

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

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. queryTypedParent​

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

Type* queryTypedParent() const;
PropertyValue
Return TypeType*
Modifiersconst const
Source LocationApp/include/v8tree/Instance.h:476
SubsystemApp - Instance Tree

How it Works Internally​

Executes queryTypedParent within App - Instance Tree.

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

How it is Used in Tests​

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

Verification Note

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

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. getTypedParent​

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

Type* getTypedParent();
PropertyValue
Return TypeType*
ModifiersNone
Source LocationApp/include/v8tree/Instance.h:483
SubsystemApp - Instance Tree

How it Works Internally​

getTypedParent

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

How it is Used in Tests​

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

Verification Note

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

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. getTypedParent​

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

Type* getTypedParent() const;
PropertyValue
Return TypeType*
Modifiersconst const
Source LocationApp/include/v8tree/Instance.h:487
SubsystemApp - Instance Tree

How it Works Internally​

Executes getTypedParent within App - Instance Tree.

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

How it is Used in Tests​

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

Verification Note

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

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. getTypedRoot​

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

Type* getTypedRoot();
PropertyValue
Return TypeType*
ModifiersNone
Source LocationApp/include/v8tree/Instance.h:494
SubsystemApp - Instance Tree

How it Works Internally​

getTypedRoot

  • 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: Pure computational logic or modifies passed-in parameters/references.
  • Key Internal Calls: RBXASSERT.

How it is Used in Tests​

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

Verification Note

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

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. getTypedRoot​

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

Type* getTypedRoot() const;
PropertyValue
Return TypeType*
Modifiersconst const
Source LocationApp/include/v8tree/Instance.h:504
SubsystemApp - Instance Tree

How it Works Internally​

Executes getTypedRoot within App - Instance Tree. Coordinates interactions with RBXASSERT.

  • 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.

How it is Used in Tests​

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

Verification Note

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

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. getChildren​

Status: 🧪 Tested  |  🌐 Cross-Platform Uniform

copy_on_write_ptr<Instances>& getChildren() const;
PropertyValue
Return Typecopy_on_write_ptr&lt;Instances&gt;&
Modifiersconst const
Source LocationApp/include/v8tree/Instance.h:514
SubsystemApp - Instance Tree

How it Works Internally​

Executes getChildren within App - Instance Tree.

  • 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):

  • WebSerializer::TestWebSerializerInstance (App.UnitTest/WebSerializerTest.cpp:115)
    • Usage Pattern: Direct Assertion
    • Assertions Checked: BOOST_CHECK(newValue.get&lt;shared_ptr&lt;Instance&gt; &gt;()-&gt;getChildren()-&gt;size() == 3)
    • Callsite Snippet: BOOST_CHECK(newValue.get&lt;shared_ptr&lt;Instance&gt; &gt;()-&gt;getChildren()-&gt;size() == 3);
  • SettingsTest::AddingPartUnderSelectionDoesNukeSettings (App.UnitTest/SettingsTest.cpp:211)
    • Usage Pattern: Direct Assertion
    • Assertions Checked: BOOST_CHECK_EQUAL((RBX::Instances*)NULL, sel-&gt;getChildren().read().get())
    • Callsite Snippet: BOOST_CHECK_EQUAL((RBX::Instances*)NULL, sel-&gt;getChildren().read().get());

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. getChildren2​

Status: 🧪 Tested  |  🌐 Cross-Platform Uniform

shared_ptr<const Instances> getChildren2();
PropertyValue
Return Typeshared_ptr&lt;const Instances&gt;
ModifiersNone
Source LocationApp/include/v8tree/Instance.h:519
SubsystemApp - Instance Tree

How it Works Internally​

Used for reflection. Note that it might return NULL (or an empty container) TODO - this is dangerous? getting const children?

  • 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: read.

How it is Used in Tests​

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

  • CustomEvents::CloneEventAndReceiver (App.UnitTest/CustomEvents.cpp:491)
    • Usage Pattern: Direct Call
    • Assertions Checked: BOOST_REQUIRE_EQUAL(2, children-&gt;size()), BOOST_REQUIRE(clonedEvent)
    • Callsite Snippet: shared_ptr&lt;const Instances&gt; children(clonedParent-&gt;getChildren2());

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. visitChildren​

Status: 🧪 Tested  |  🌐 Cross-Platform Uniform

void visitChildren(const Func& func) const;
PropertyValue
Return Typevoid
Modifiersinline const
Source LocationApp/include/v8tree/Instance.h:520
SubsystemApp - Instance Tree

How it Works Internally​

Executes visitChildren within App - Instance Tree. Coordinates interactions with read, end, begin. Employs reference-counted heap object ownership (boost::shared_ptr).

  • Control Flow & Execution: Iterative loop processing, Conditional branching.
  • Memory Management: 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: Immutable / read-only operation (const member method; does not alter object state).
  • Key Internal Calls: read, end, begin.
  • External Library Dependencies: Boost C++ Libraries.

How it is Used in Tests​

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

  • LuaDebugger::FlatDataSerialization (App.UnitTest/LuaDebugger.cpp:139)
    • Usage Pattern: Direct Call
    • Assertions Checked: BOOST_CHECK(workspace != NULL), BOOST_CHECK(debuggerManager.getDataModel() != NULL)
    • Callsite Snippet: workspace-&gt;visitChildren(boost::bind(&addDebuggerData, _1, shared_from(&debuggerManager), debuggerData));

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. countDescendantsOfType​

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

int countDescendantsOfType() const;
PropertyValue
Return Typeint
Modifiersinline const
Source LocationApp/include/v8tree/Instance.h:533
SubsystemApp - Instance Tree

How it Works Internally​

Executes countDescendantsOfType within App - Instance Tree. Coordinates interactions with read, end, begin. Employs reference-counted heap object ownership (boost::shared_ptr).

  • Control Flow & Execution: Iterative loop processing, Conditional branching, Explicit result return.
  • Memory Management: 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: Immutable / read-only operation (const member method; does not alter object state).
  • Key Internal Calls: read, end, begin.
  • External Library Dependencies: Boost C++ Libraries.

How it is Used in Tests​

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

Verification Note

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

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. visitDescendants​

Status: 🧪 Tested  |  🌐 Cross-Platform Uniform

void visitDescendants(const Func& func) const;
PropertyValue
Return Typevoid
Modifiersinline const
Source LocationApp/include/v8tree/Instance.h:548
SubsystemApp - Instance Tree

How it Works Internally​

Executes visitDescendants within App - Instance Tree. Coordinates interactions with read, end, begin. Employs reference-counted heap object ownership (boost::shared_ptr).

  • Control Flow & Execution: Iterative loop processing, Conditional branching.
  • Memory Management: 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: Immutable / read-only operation (const member method; does not alter object state).
  • Key Internal Calls: read, end, begin.
  • External Library Dependencies: Boost C++ Libraries.

How it is Used in Tests​

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

  • LuaDebugger::NestedDataSerialization (App.UnitTest/LuaDebugger.cpp:211)
    • Usage Pattern: Direct Call
    • Assertions Checked: BOOST_CHECK(workspace != NULL), BOOST_CHECK(debuggerManager.getDataModel() != NULL)
    • Callsite Snippet: workspace-&gt;visitDescendants(boost::bind(&addDebuggerData, _1, shared_from(&debuggerManager), debuggerData));

Behavioral Differences Across Code Files​

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


Additional Functions

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