App - Serialization & XML
DataModel serializer, WebSerializer, Binary format, and XML persistence.
Subsystem Metrics
- Total Documented Functions:
169 - Functions Exercised in Tests:
41 - Platform-Divergent Implementations:
3 - Component Source Files:
11
Source Files
View all 11 source files in this subsystem
| Source File | Path |
|---|---|
Reference.h | App/include/v8xml/Reference.h |
Serializer.h | App/include/v8xml/Serializer.h |
SerializerV2.h | App/include/v8xml/SerializerV2.h |
XmlElement.h | App/include/v8xml/XmlElement.h |
XmlSerializer.h | App/include/v8xml/XmlSerializer.h |
SerializerBinary.cpp | App/v8xml/SerializerBinary.cpp |
SerializerV2.cpp | App/v8xml/SerializerV2.cpp |
WebParser.cpp | App/v8xml/WebParser.cpp |
WebSerializer.cpp | App/v8xml/WebSerializer.cpp |
XmlElement.cpp | App/v8xml/XmlElement.cpp |
XmlSerializer.cpp | App/v8xml/XmlSerializer.cpp |
Function Reference
1. ~IReferenceBinder
Status: ⚪ Untested in Suites | 🌐 Cross-Platform Uniform
virtual ~IReferenceBinder();
| Property | Value |
|---|---|
| Return Type | virtual |
| Modifiers | None |
| Source Location | App/include/v8xml/Reference.h:38 |
| Subsystem | App - Serialization & XML |
How it Works Internally
Declaration or inline method for ~IReferenceBinder.
- 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 ~IReferenceBinder.
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. assign
Status: 🧪 Tested | 🌐 Cross-Platform Uniform
protected:
void assign(const IIDREF* idref, Reflection::DescribedBase* propertyOwner, const InstanceHandle& handle);
| Property | Value |
|---|---|
| Return Type | `protected: |
| void` | |
| Modifiers | None |
| Source Location | App/include/v8xml/Reference.h:39 |
| Subsystem | App - Serialization & XML |
How it Works Internally
Executes assign within App - Serialization & XML. Coordinates interactions with assignIDREF.
- 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:
assignIDREF.
How it is Used in Tests
This function is exercised in 1 test case(s):
ClusterDeltaBuffer::InitialCachedChunksRemainFifoAcrossBatches(App.UnitTest/ClusterReplicationTest.cpp:1125)- Usage Pattern:
Direct Call - Assertions Checked:
BOOST_CHECK(data.hasDataToSend()),BOOST_CHECK(data.initialChunkIterator.front() == chunks[0]) - Callsite Snippet:
data.initialChunkIterator.assign(chunks.begin(), chunks.end());
- 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.
3. canWriteChild
Status: ⚪ Untested in Suites | 🌐 Cross-Platform Uniform
bool canWriteChild(const shared_ptr<RBX::Instance> instance, RBX::Instance::SaveFilter saveFilter);
| Property | Value |
|---|---|
| Return Type | bool |
| Modifiers | static |
| Source Location | App/include/v8xml/Serializer.h:23 |
| Subsystem | App - Serialization & XML |
How it Works Internally
Executes canWriteChild within App - Serialization & XML. Coordinates interactions with getIsArchivable, get.
- Control Flow & Execution: Conditional branching, Multi-case state dispatch, 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:
getIsArchivable,get.
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 canWriteChild.
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. announceID
Status: ⚪ Untested in Suites | 🌐 Cross-Platform Uniform
void announceID(const XmlNameValuePair* valueID, Reflection::DescribedBase* target);
| Property | Value |
|---|---|
| Return Type | void |
| Modifiers | virtual |
| Source Location | App/include/v8xml/SerializerV2.h:68 |
| Subsystem | App - Serialization & XML |
How it Works Internally
Executes announceID within App - Serialization & XML. Coordinates interactions with processID.
- 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:
processID.
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 announceID.
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. announceIDREF
Status: ⚪ Untested in Suites | 🌐 Cross-Platform Uniform
void announceIDREF(const XmlNameValuePair* valueIDREF, Reflection::DescribedBase* propertyOwner, const IIDREF* idref);
| Property | Value |
|---|---|
| Return Type | void |
| Modifiers | virtual |
| Source Location | App/include/v8xml/SerializerV2.h:71 |
| Subsystem | App - Serialization & XML |
How it Works Internally
Executes announceIDREF within App - Serialization & XML. Coordinates interactions with processIDREF, RBXASSERT.
- 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: Engine invariant assertion check (RBXASSERT).
- State Mutation: Pure computational logic or modifies passed-in parameters/references.
- Key Internal Calls:
processIDREF,RBXASSERT.
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 announceIDREF.
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. resolveRefs
Status: ⚪ Untested in Suites | 🌐 Cross-Platform Uniform
bool resolveRefs();
| Property | Value |
|---|---|
| Return Type | bool |
| Modifiers | virtual |
| Source Location | App/include/v8xml/SerializerV2.h:75 |
| Subsystem | App - Serialization & XML |
How it Works Internally
Executes resolveRefs within App - Serialization & XML. Coordinates interactions with begin, end, assign, clear.
- Control Flow & Execution: Iterative loop processing, 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:
begin,end,assign,clear.
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 resolveRefs.
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. processID
Status: ⚪ Untested in Suites | 🌐 Cross-Platform Uniform
bool processID(const XmlNameValuePair* valueID, Reflection::DescribedBase* source);
| Property | Value |
|---|---|
| Return Type | bool |
| Modifiers | virtual |
| Source Location | App/include/v8xml/SerializerV2.h:89 |
| Subsystem | App - Serialization & XML |
How it Works Internally
Executes processID within App - Serialization & XML. Coordinates interactions with getValue, linkTo, shared_from, isValueEqual.
- 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:
getValue,linkTo,shared_from,isValueEqual.
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 processID.
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. processIDREF
Status: ⚪ Untested in Suites | 🌐 Cross-Platform Uniform
bool processIDREF(const XmlNameValuePair* valueIDREF, Reflection::DescribedBase* propertyOwner, const IIDREF* idref);
| Property | Value |
|---|---|
| Return Type | bool |
| Modifiers | virtual |
| Source Location | App/include/v8xml/SerializerV2.h:99 |
| Subsystem | App - Serialization & XML |
How it Works Internally
Executes processIDREF within App - Serialization & XML. Coordinates interactions with getValue, empty, assign, push_back.
- 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:
getValue,empty,assign,push_back,isValueEqual.
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 processIDREF.
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. getTag
Status: ⚪ Untested in Suites | 🌐 Cross-Platform Uniform
XmlTag& getTag() const;
| Property | Value |
|---|---|
| Return Type | XmlTag& |
| Modifiers | const const |
| Source Location | App/include/v8xml/XmlElement.h:169 |
| Subsystem | App - Serialization & XML |
How it Works Internally
Executes getTag within App - Serialization & XML.
- 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 getTag.
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. isValueEmpty
Status: ⚪ Untested in Suites | 🌐 Cross-Platform Uniform
bool isValueEmpty() const;
| Property | Value |
|---|---|
| Return Type | bool |
| Modifiers | const |
| Source Location | App/include/v8xml/XmlElement.h:170 |
| Subsystem | App - Serialization & XML |
How it Works Internally
Executes isValueEmpty within App - Serialization & XML.
- 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 isValueEmpty.
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. getValueType
Status: ⚪ Untested in Suites | 🌐 Cross-Platform Uniform
ValueType getValueType() const;
| Property | Value |
|---|---|
| Return Type | ValueType |
| Modifiers | const |
| Source Location | App/include/v8xml/XmlElement.h:191 |
| Subsystem | App - Serialization & XML |
How it Works Internally
Executes getValueType within App - Serialization & XML.
- 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 getValueType.
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. setValue
Status: 🧪 Tested | 🌐 Cross-Platform Uniform
void setValue(std::string value);
| Property | Value |
|---|---|
| Return Type | void |
| Modifiers | None |
| Source Location | App/include/v8xml/XmlElement.h:207 |
| Subsystem | App - Serialization & XML |
How it Works Internally
Executes setValue within App - Serialization & XML. Coordinates interactions with clearValue, string. Employs dynamic heap allocation via c++ operator new.
- Control Flow & Execution: Direct sequential execution.
- Memory Management: Dynamic heap allocation via C++ operator new.
- 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:
clearValue,string.
How it is Used in Tests
This function is exercised in 3 test case(s):
AutowedgeTest::ExplosionBelowTerrainWorks(App.UnitTest/AutowedgeTest.cpp:247)- Usage Pattern:
Direct Call - Assertions Checked:
BOOST_REQUIRE_EQUAL(fixture.cluster->getVoxelGrid()->getCellMaterial(Vector3int16(kOffset, 0, kOffset)), CELL_MATERIAL_Grass),BOOST_REQUIRE(check) - Callsite Snippet:
Explosion::propPosition.setValue(exp.get(), Vector3(0,2,0));
- Usage Pattern:
AutowedgeTest::ExplosionAboveTerrainWorks(App.UnitTest/AutowedgeTest.cpp:270)- Usage Pattern:
Direct Call - Assertions Checked:
BOOST_REQUIRE_EQUAL(fixture.cluster->getVoxelGrid()->getCellMaterial(Vector3int16(kOffset, 62, kOffset)), CELL_MATERIAL_Grass),BOOST_REQUIRE(check) - Callsite Snippet:
Explosion::propPosition.setValue(exp.get(), Vector3(0,240,0));
- Usage Pattern:
PropertyChangedSignal::WorksOnNonPartInstances(App.UnitTest/PropertyChangedSignal.cpp:258)- Usage Pattern:
Direct Call - Assertions Checked:
BOOST_CHECK_EQUAL(scriptInt(*this, "return valueChanges"), 1),BOOST_CHECK_EQUAL(scriptInt(*this, "return valueChanges"), 1) - Callsite Snippet:
value->setValue("hello");
- 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.
13. setValue
Status: 🧪 Tested | 🌐 Cross-Platform Uniform
void setValue(RBX::ContentId contentId);
| Property | Value |
|---|---|
| Return Type | void |
| Modifiers | None |
| Source Location | App/include/v8xml/XmlElement.h:209 |
| Subsystem | App - Serialization & XML |
How it Works Internally
Executes setValue within App - Serialization & XML. Coordinates interactions with clearValue, ContentId. Employs dynamic heap allocation via c++ operator new.
- Control Flow & Execution: Direct sequential execution.
- Memory Management: Dynamic heap allocation via C++ operator new.
- 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:
clearValue,ContentId.
How it is Used in Tests
This function is exercised in 3 test case(s):
AutowedgeTest::ExplosionBelowTerrainWorks(App.UnitTest/AutowedgeTest.cpp:247)- Usage Pattern:
Direct Call - Assertions Checked:
BOOST_REQUIRE_EQUAL(fixture.cluster->getVoxelGrid()->getCellMaterial(Vector3int16(kOffset, 0, kOffset)), CELL_MATERIAL_Grass),BOOST_REQUIRE(check) - Callsite Snippet:
Explosion::propPosition.setValue(exp.get(), Vector3(0,2,0));
- Usage Pattern:
AutowedgeTest::ExplosionAboveTerrainWorks(App.UnitTest/AutowedgeTest.cpp:270)- Usage Pattern:
Direct Call - Assertions Checked:
BOOST_REQUIRE_EQUAL(fixture.cluster->getVoxelGrid()->getCellMaterial(Vector3int16(kOffset, 62, kOffset)), CELL_MATERIAL_Grass),BOOST_REQUIRE(check) - Callsite Snippet:
Explosion::propPosition.setValue(exp.get(), Vector3(0,240,0));
- Usage Pattern:
PropertyChangedSignal::WorksOnNonPartInstances(App.UnitTest/PropertyChangedSignal.cpp:258)- Usage Pattern:
Direct Call - Assertions Checked:
BOOST_CHECK_EQUAL(scriptInt(*this, "return valueChanges"), 1),BOOST_CHECK_EQUAL(scriptInt(*this, "return valueChanges"), 1) - Callsite Snippet:
value->setValue("hello");
- 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.
14. setValue
Status: 🧪 Tested | 🌐 Cross-Platform Uniform
void setValue(const char* value);
| Property | Value |
|---|---|
| Return Type | void |
| Modifiers | None |
| Source Location | App/include/v8xml/XmlElement.h:210 |
| Subsystem | App - Serialization & XML |
How it Works Internally
Executes setValue within App - Serialization & XML. Coordinates interactions with clearValue, string. Employs dynamic heap allocation via c++ operator new.
- Control Flow & Execution: Direct sequential execution.
- Memory Management: Dynamic heap allocation via C++ operator new.
- 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:
clearValue,string.
How it is Used in Tests
This function is exercised in 3 test case(s):
AutowedgeTest::ExplosionBelowTerrainWorks(App.UnitTest/AutowedgeTest.cpp:247)- Usage Pattern:
Direct Call - Assertions Checked:
BOOST_REQUIRE_EQUAL(fixture.cluster->getVoxelGrid()->getCellMaterial(Vector3int16(kOffset, 0, kOffset)), CELL_MATERIAL_Grass),BOOST_REQUIRE(check) - Callsite Snippet:
Explosion::propPosition.setValue(exp.get(), Vector3(0,2,0));
- Usage Pattern:
AutowedgeTest::ExplosionAboveTerrainWorks(App.UnitTest/AutowedgeTest.cpp:270)- Usage Pattern:
Direct Call - Assertions Checked:
BOOST_REQUIRE_EQUAL(fixture.cluster->getVoxelGrid()->getCellMaterial(Vector3int16(kOffset, 62, kOffset)), CELL_MATERIAL_Grass),BOOST_REQUIRE(check) - Callsite Snippet:
Explosion::propPosition.setValue(exp.get(), Vector3(0,240,0));
- Usage Pattern:
PropertyChangedSignal::WorksOnNonPartInstances(App.UnitTest/PropertyChangedSignal.cpp:258)- Usage Pattern:
Direct Call - Assertions Checked:
BOOST_CHECK_EQUAL(scriptInt(*this, "return valueChanges"), 1),BOOST_CHECK_EQUAL(scriptInt(*this, "return valueChanges"), 1) - Callsite Snippet:
value->setValue("hello");
- 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.
15. setValue
Status: 🧪 Tested | 🌐 Cross-Platform Uniform
void setValue(int value);
| Property | Value |
|---|---|
| Return Type | void |
| Modifiers | None |
| Source Location | App/include/v8xml/XmlElement.h:211 |
| Subsystem | App - Serialization & XML |
How it Works Internally
Executes setValue within App - Serialization & XML. Coordinates interactions with clearValue.
- 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:
clearValue.
How it is Used in Tests
This function is exercised in 3 test case(s):
AutowedgeTest::ExplosionBelowTerrainWorks(App.UnitTest/AutowedgeTest.cpp:247)- Usage Pattern:
Direct Call - Assertions Checked:
BOOST_REQUIRE_EQUAL(fixture.cluster->getVoxelGrid()->getCellMaterial(Vector3int16(kOffset, 0, kOffset)), CELL_MATERIAL_Grass),BOOST_REQUIRE(check) - Callsite Snippet:
Explosion::propPosition.setValue(exp.get(), Vector3(0,2,0));
- Usage Pattern:
AutowedgeTest::ExplosionAboveTerrainWorks(App.UnitTest/AutowedgeTest.cpp:270)- Usage Pattern:
Direct Call - Assertions Checked:
BOOST_REQUIRE_EQUAL(fixture.cluster->getVoxelGrid()->getCellMaterial(Vector3int16(kOffset, 62, kOffset)), CELL_MATERIAL_Grass),BOOST_REQUIRE(check) - Callsite Snippet:
Explosion::propPosition.setValue(exp.get(), Vector3(0,240,0));
- Usage Pattern:
PropertyChangedSignal::WorksOnNonPartInstances(App.UnitTest/PropertyChangedSignal.cpp:258)- Usage Pattern:
Direct Call - Assertions Checked:
BOOST_CHECK_EQUAL(scriptInt(*this, "return valueChanges"), 1),BOOST_CHECK_EQUAL(scriptInt(*this, "return valueChanges"), 1) - Callsite Snippet:
value->setValue("hello");
- 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.
16. setValue
Status: 🧪 Tested | 🌐 Cross-Platform Uniform
void setValue(unsigned int value);
| Property | Value |
|---|---|
| Return Type | void |
| Modifiers | None |
| Source Location | App/include/v8xml/XmlElement.h:212 |
| Subsystem | App - Serialization & XML |
How it Works Internally
Executes setValue within App - Serialization & XML. Coordinates interactions with clearValue.
- 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:
clearValue.
How it is Used in Tests
This function is exercised in 3 test case(s):
AutowedgeTest::ExplosionBelowTerrainWorks(App.UnitTest/AutowedgeTest.cpp:247)- Usage Pattern:
Direct Call - Assertions Checked:
BOOST_REQUIRE_EQUAL(fixture.cluster->getVoxelGrid()->getCellMaterial(Vector3int16(kOffset, 0, kOffset)), CELL_MATERIAL_Grass),BOOST_REQUIRE(check) - Callsite Snippet:
Explosion::propPosition.setValue(exp.get(), Vector3(0,2,0));
- Usage Pattern:
AutowedgeTest::ExplosionAboveTerrainWorks(App.UnitTest/AutowedgeTest.cpp:270)- Usage Pattern:
Direct Call - Assertions Checked:
BOOST_REQUIRE_EQUAL(fixture.cluster->getVoxelGrid()->getCellMaterial(Vector3int16(kOffset, 62, kOffset)), CELL_MATERIAL_Grass),BOOST_REQUIRE(check) - Callsite Snippet:
Explosion::propPosition.setValue(exp.get(), Vector3(0,240,0));
- Usage Pattern:
PropertyChangedSignal::WorksOnNonPartInstances(App.UnitTest/PropertyChangedSignal.cpp:258)- Usage Pattern:
Direct Call - Assertions Checked:
BOOST_CHECK_EQUAL(scriptInt(*this, "return valueChanges"), 1),BOOST_CHECK_EQUAL(scriptInt(*this, "return valueChanges"), 1) - Callsite Snippet:
value->setValue("hello");
- 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.
17. setValue
Status: 🧪 Tested | 🌐 Cross-Platform Uniform
void setValue(bool value);
| Property | Value |
|---|---|
| Return Type | void |
| Modifiers | None |
| Source Location | App/include/v8xml/XmlElement.h:213 |
| Subsystem | App - Serialization & XML |
How it Works Internally
Executes setValue within App - Serialization & XML. Coordinates interactions with clearValue.
- 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:
clearValue.
How it is Used in Tests
This function is exercised in 3 test case(s):
AutowedgeTest::ExplosionBelowTerrainWorks(App.UnitTest/AutowedgeTest.cpp:247)- Usage Pattern:
Direct Call - Assertions Checked:
BOOST_REQUIRE_EQUAL(fixture.cluster->getVoxelGrid()->getCellMaterial(Vector3int16(kOffset, 0, kOffset)), CELL_MATERIAL_Grass),BOOST_REQUIRE(check) - Callsite Snippet:
Explosion::propPosition.setValue(exp.get(), Vector3(0,2,0));
- Usage Pattern:
AutowedgeTest::ExplosionAboveTerrainWorks(App.UnitTest/AutowedgeTest.cpp:270)- Usage Pattern:
Direct Call - Assertions Checked:
BOOST_REQUIRE_EQUAL(fixture.cluster->getVoxelGrid()->getCellMaterial(Vector3int16(kOffset, 62, kOffset)), CELL_MATERIAL_Grass),BOOST_REQUIRE(check) - Callsite Snippet:
Explosion::propPosition.setValue(exp.get(), Vector3(0,240,0));
- Usage Pattern:
PropertyChangedSignal::WorksOnNonPartInstances(App.UnitTest/PropertyChangedSignal.cpp:258)- Usage Pattern:
Direct Call - Assertions Checked:
BOOST_CHECK_EQUAL(scriptInt(*this, "return valueChanges"), 1),BOOST_CHECK_EQUAL(scriptInt(*this, "return valueChanges"), 1) - Callsite Snippet:
value->setValue("hello");
- 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.
18. setValue
Status: 🧪 Tested | 🌐 Cross-Platform Uniform
void setValue(float value);
| Property | Value |
|---|---|
| Return Type | void |
| Modifiers | None |
| Source Location | App/include/v8xml/XmlElement.h:214 |
| Subsystem | App - Serialization & XML |
How it Works Internally
Executes setValue within App - Serialization & XML. Coordinates interactions with clearValue.
- 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:
clearValue.
How it is Used in Tests
This function is exercised in 3 test case(s):
AutowedgeTest::ExplosionBelowTerrainWorks(App.UnitTest/AutowedgeTest.cpp:247)- Usage Pattern:
Direct Call - Assertions Checked:
BOOST_REQUIRE_EQUAL(fixture.cluster->getVoxelGrid()->getCellMaterial(Vector3int16(kOffset, 0, kOffset)), CELL_MATERIAL_Grass),BOOST_REQUIRE(check) - Callsite Snippet:
Explosion::propPosition.setValue(exp.get(), Vector3(0,2,0));
- Usage Pattern:
AutowedgeTest::ExplosionAboveTerrainWorks(App.UnitTest/AutowedgeTest.cpp:270)- Usage Pattern:
Direct Call - Assertions Checked:
BOOST_REQUIRE_EQUAL(fixture.cluster->getVoxelGrid()->getCellMaterial(Vector3int16(kOffset, 62, kOffset)), CELL_MATERIAL_Grass),BOOST_REQUIRE(check) - Callsite Snippet:
Explosion::propPosition.setValue(exp.get(), Vector3(0,240,0));
- Usage Pattern:
PropertyChangedSignal::WorksOnNonPartInstances(App.UnitTest/PropertyChangedSignal.cpp:258)- Usage Pattern:
Direct Call - Assertions Checked:
BOOST_CHECK_EQUAL(scriptInt(*this, "return valueChanges"), 1),BOOST_CHECK_EQUAL(scriptInt(*this, "return valueChanges"), 1) - Callsite Snippet:
value->setValue("hello");
- 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.
19. setValue
Status: 🧪 Tested | 🌐 Cross-Platform Uniform
void setValue(double value);
| Property | Value |
|---|---|
| Return Type | void |
| Modifiers | None |
| Source Location | App/include/v8xml/XmlElement.h:215 |
| Subsystem | App - Serialization & XML |
How it Works Internally
Executes setValue within App - Serialization & XML. Coordinates interactions with clearValue.
- 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:
clearValue.
How it is Used in Tests
This function is exercised in 3 test case(s):
AutowedgeTest::ExplosionBelowTerrainWorks(App.UnitTest/AutowedgeTest.cpp:247)- Usage Pattern:
Direct Call - Assertions Checked:
BOOST_REQUIRE_EQUAL(fixture.cluster->getVoxelGrid()->getCellMaterial(Vector3int16(kOffset, 0, kOffset)), CELL_MATERIAL_Grass),BOOST_REQUIRE(check) - Callsite Snippet:
Explosion::propPosition.setValue(exp.get(), Vector3(0,2,0));
- Usage Pattern:
AutowedgeTest::ExplosionAboveTerrainWorks(App.UnitTest/AutowedgeTest.cpp:270)- Usage Pattern:
Direct Call - Assertions Checked:
BOOST_REQUIRE_EQUAL(fixture.cluster->getVoxelGrid()->getCellMaterial(Vector3int16(kOffset, 62, kOffset)), CELL_MATERIAL_Grass),BOOST_REQUIRE(check) - Callsite Snippet:
Explosion::propPosition.setValue(exp.get(), Vector3(0,240,0));
- Usage Pattern:
PropertyChangedSignal::WorksOnNonPartInstances(App.UnitTest/PropertyChangedSignal.cpp:258)- Usage Pattern:
Direct Call - Assertions Checked:
BOOST_CHECK_EQUAL(scriptInt(*this, "return valueChanges"), 1),BOOST_CHECK_EQUAL(scriptInt(*this, "return valueChanges"), 1) - Callsite Snippet:
value->setValue("hello");
- 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. setValue
Status: 🧪 Tested | 🌐 Cross-Platform Uniform
void setValue(const RBX::Name* value);
| Property | Value |
|---|---|
| Return Type | void |
| Modifiers | None |
| Source Location | App/include/v8xml/XmlElement.h:216 |
| Subsystem | App - Serialization & XML |
How it Works Internally
Executes setValue within App - Serialization & XML. Coordinates interactions with clearValue.
- 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:
clearValue.
How it is Used in Tests
This function is exercised in 3 test case(s):
AutowedgeTest::ExplosionBelowTerrainWorks(App.UnitTest/AutowedgeTest.cpp:247)- Usage Pattern:
Direct Call - Assertions Checked:
BOOST_REQUIRE_EQUAL(fixture.cluster->getVoxelGrid()->getCellMaterial(Vector3int16(kOffset, 0, kOffset)), CELL_MATERIAL_Grass),BOOST_REQUIRE(check) - Callsite Snippet:
Explosion::propPosition.setValue(exp.get(), Vector3(0,2,0));
- Usage Pattern:
AutowedgeTest::ExplosionAboveTerrainWorks(App.UnitTest/AutowedgeTest.cpp:270)- Usage Pattern:
Direct Call - Assertions Checked:
BOOST_REQUIRE_EQUAL(fixture.cluster->getVoxelGrid()->getCellMaterial(Vector3int16(kOffset, 62, kOffset)), CELL_MATERIAL_Grass),BOOST_REQUIRE(check) - Callsite Snippet:
Explosion::propPosition.setValue(exp.get(), Vector3(0,240,0));
- Usage Pattern:
PropertyChangedSignal::WorksOnNonPartInstances(App.UnitTest/PropertyChangedSignal.cpp:258)- Usage Pattern:
Direct Call - Assertions Checked:
BOOST_CHECK_EQUAL(scriptInt(*this, "return valueChanges"), 1),BOOST_CHECK_EQUAL(scriptInt(*this, "return valueChanges"), 1) - Callsite Snippet:
value->setValue("hello");
- 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.
21. setValue
Status: 🧪 Tested | 🌐 Cross-Platform Uniform
void setValue(RBX::InstanceHandle handle);
| Property | Value |
|---|---|
| Return Type | void |
| Modifiers | None |
| Source Location | App/include/v8xml/XmlElement.h:217 |
| Subsystem | App - Serialization & XML |
How it Works Internally
Executes setValue within App - Serialization & XML. Coordinates interactions with clearValue, InstanceHandle. Employs dynamic heap allocation via c++ operator new.
- Control Flow & Execution: Direct sequential execution.
- Memory Management: Dynamic heap allocation via C++ operator new.
- 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:
clearValue,InstanceHandle.
How it is Used in Tests
This function is exercised in 3 test case(s):
AutowedgeTest::ExplosionBelowTerrainWorks(App.UnitTest/AutowedgeTest.cpp:247)- Usage Pattern:
Direct Call - Assertions Checked:
BOOST_REQUIRE_EQUAL(fixture.cluster->getVoxelGrid()->getCellMaterial(Vector3int16(kOffset, 0, kOffset)), CELL_MATERIAL_Grass),BOOST_REQUIRE(check) - Callsite Snippet:
Explosion::propPosition.setValue(exp.get(), Vector3(0,2,0));
- Usage Pattern:
AutowedgeTest::ExplosionAboveTerrainWorks(App.UnitTest/AutowedgeTest.cpp:270)- Usage Pattern:
Direct Call - Assertions Checked:
BOOST_REQUIRE_EQUAL(fixture.cluster->getVoxelGrid()->getCellMaterial(Vector3int16(kOffset, 62, kOffset)), CELL_MATERIAL_Grass),BOOST_REQUIRE(check) - Callsite Snippet:
Explosion::propPosition.setValue(exp.get(), Vector3(0,240,0));
- Usage Pattern:
PropertyChangedSignal::WorksOnNonPartInstances(App.UnitTest/PropertyChangedSignal.cpp:258)- Usage Pattern:
Direct Call - Assertions Checked:
BOOST_CHECK_EQUAL(scriptInt(*this, "return valueChanges"), 1),BOOST_CHECK_EQUAL(scriptInt(*this, "return valueChanges"), 1) - Callsite Snippet:
value->setValue("hello");
- 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.
22. pushBackChild
Status: ⚪ Untested in Suites | 🌐 Cross-Platform Uniform
void pushBackChild(ChildClass* child);
| Property | Value |
|---|---|
| Return Type | void |
| Modifiers | None |
| Source Location | App/include/v8xml/XmlElement.h:238 |
| Subsystem | App - Serialization & XML |
How it Works Internally
Executes pushBackChild within App - Serialization & XML. Coordinates interactions with setNextSibling.
- 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:
setNextSibling.
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 pushBackChild.
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. pushFrontChild
Status: ⚪ Untested in Suites | 🌐 Cross-Platform Uniform
void pushFrontChild(ChildClass* child);
| Property | Value |
|---|---|
| Return Type | void |
| Modifiers | None |
| Source Location | App/include/v8xml/XmlElement.h:246 |
| Subsystem | App - Serialization & XML |
How it Works Internally
Executes pushFrontChild within App - Serialization & XML. Coordinates interactions with setNextSibling.
- 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:
setNextSibling.
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 pushFrontChild.
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. addChild
Status: ⚪ Untested in Suites | 🌐 Cross-Platform Uniform
void addChild(ChildClass* child);
| Property | Value |
|---|---|
| Return Type | void |
| Modifiers | None |
| Source Location | App/include/v8xml/XmlElement.h:254 |
| Subsystem | App - Serialization & XML |
How it Works Internally
Executes addChild within App - Serialization & XML. Coordinates interactions with pushBackChild.
- 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:
pushBackChild.
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 addChild.
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. removeChild
Status: ⚪ Untested in Suites | 🌐 Cross-Platform Uniform
void removeChild(ChildClass* child);
| Property | Value |
|---|---|
| Return Type | void |
| Modifiers | None |
| Source Location | App/include/v8xml/XmlElement.h:258 |
| Subsystem | App - Serialization & XML |
How it Works Internally
Executes removeChild within App - Serialization & XML. Coordinates interactions with nextSibling, setNextSibling.
- Control Flow & Execution: Iterative loop processing, 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:
nextSibling,setNextSibling.
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 removeChild.
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. firstChild
Status: ⚪ Untested in Suites | 🌐 Cross-Platform Uniform
ChildClass* firstChild();
| Property | Value |
|---|---|
| Return Type | ChildClass* |
| Modifiers | None |
| Source Location | App/include/v8xml/XmlElement.h:274 |
| Subsystem | App - Serialization & XML |
How it Works Internally
Executes firstChild within App - Serialization & XML.
- 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 firstChild.
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. nextChild
Status: ⚪ Untested in Suites | 🌐 Cross-Platform Uniform
ChildClass* nextChild(ChildClass* child);
| Property | Value |
|---|---|
| Return Type | ChildClass* |
| Modifiers | None |
| Source Location | App/include/v8xml/XmlElement.h:276 |
| Subsystem | App - Serialization & XML |
How it Works Internally
Executes nextChild within App - Serialization & XML. Coordinates interactions with nextSibling.
- 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:
nextSibling.
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 nextChild.
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. firstChild
Status: ⚪ Untested in Suites | 🌐 Cross-Platform Uniform
ChildClass* firstChild() const;
| Property | Value |
|---|---|
| Return Type | ChildClass* |
| Modifiers | const const |
| Source Location | App/include/v8xml/XmlElement.h:277 |
| Subsystem | App - Serialization & XML |
How it Works Internally
Executes firstChild within App - Serialization & XML.
- 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 firstChild.
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. nextChild
Status: ⚪ Untested in Suites | 🌐 Cross-Platform Uniform
ChildClass* nextChild(const ChildClass* child) const;
| Property | Value |
|---|---|
| Return Type | ChildClass* |
| Modifiers | const const |
| Source Location | App/include/v8xml/XmlElement.h:278 |
| Subsystem | App - Serialization & XML |
How it Works Internally
Executes nextChild within App - Serialization & XML. Coordinates interactions with nextSibling.
- 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:
nextSibling.
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 nextChild.
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. nextSibling
Status: ⚪ Untested in Suites | 🌐 Cross-Platform Uniform
SiblingClass* nextSibling() const;
| Property | Value |
|---|---|
| Return Type | SiblingClass* |
| Modifiers | const const |
| Source Location | App/include/v8xml/XmlElement.h:290 |
| Subsystem | App - Serialization & XML |
How it Works Internally
Executes nextSibling within App - Serialization & XML.
- 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 nextSibling.
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. nextSibling
Status: ⚪ Untested in Suites | 🌐 Cross-Platform Uniform
SiblingClass* nextSibling();
| Property | Value |
|---|---|
| Return Type | SiblingClass* |
| Modifiers | None |
| Source Location | App/include/v8xml/XmlElement.h:291 |
| Subsystem | App - Serialization & XML |
How it Works Internally
Executes nextSibling within App - Serialization & XML.
- 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 nextSibling.
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. setNextSibling
Status: ⚪ Untested in Suites | 🌐 Cross-Platform Uniform
void setNextSibling(SiblingClass* nextSibling);
| Property | Value |
|---|---|
| Return Type | void |
| Modifiers | None |
| Source Location | App/include/v8xml/XmlElement.h:294 |
| Subsystem | App - Serialization & XML |
How it Works Internally
Executes setNextSibling within App - Serialization & XML.
- 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: Mutates internal member state or instance properties.
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 setNextSibling.
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. recordLeak
Status: ⚪ Untested in Suites | 🌐 Cross-Platform Uniform
void recordLeak();
| Property | Value |
|---|---|
| Return Type | void |
| Modifiers | None |
| Source Location | App/include/v8xml/XmlElement.h:319 |
| Subsystem | App - Serialization & XML |
How it Works Internally
Executes recordLeak within App - Serialization & XML. Coordinates interactions with strcpy.
- 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:
strcpy.
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 recordLeak.
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. addAttribute
Status: ⚪ Untested in Suites | 🌐 Cross-Platform Uniform
void addAttribute(const XmlTag& _tag, T value);
| Property | Value |
|---|---|
| Return Type | void |
| Modifiers | inline |
| Source Location | App/include/v8xml/XmlElement.h:369 |
| Subsystem | App - Serialization & XML |
How it Works Internally
Executes addAttribute within App - Serialization & XML. Coordinates interactions with XmlAttribute. Employs dynamic heap allocation via c++ operator new.
- Control Flow & Execution: Direct sequential execution.
- Memory Management: Dynamic heap allocation via C++ operator new.
- 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:
XmlAttribute.
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 addAttribute.
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. getFirstAttribute
Status: ⚪ Untested in Suites | 🌐 Cross-Platform Uniform
XmlAttribute* getFirstAttribute() const;
| Property | Value |
|---|---|
| Return Type | XmlAttribute* |
| Modifiers | inline const const |
| Source Location | App/include/v8xml/XmlElement.h:375 |
| Subsystem | App - Serialization & XML |
How it Works Internally
Executes getFirstAttribute within App - Serialization & XML. Coordinates interactions with firstChild.
- 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:
firstChild.
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 getFirstAttribute.
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. getNextAttribute
Status: ⚪ Untested in Suites | 🌐 Cross-Platform Uniform
XmlAttribute* getNextAttribute(const XmlAttribute* attribute) const;
| Property | Value |
|---|---|
| Return Type | XmlAttribute* |
| Modifiers | inline const const |
| Source Location | App/include/v8xml/XmlElement.h:377 |
| Subsystem | App - Serialization & XML |
How it Works Internally
Executes getNextAttribute within App - Serialization & XML. Coordinates interactions with nextChild.
- 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:
nextChild.
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 getNextAttribute.
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. getFirstAttribute
Status: ⚪ Untested in Suites | 🌐 Cross-Platform Uniform
XmlAttribute* getFirstAttribute();
| Property | Value |
|---|---|
| Return Type | XmlAttribute* |
| Modifiers | inline |
| Source Location | App/include/v8xml/XmlElement.h:378 |
| Subsystem | App - Serialization & XML |
How it Works Internally
Executes getFirstAttribute within App - Serialization & XML. Coordinates interactions with firstChild.
- 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:
firstChild.
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 getFirstAttribute.
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. getNextAttribute
Status: ⚪ Untested in Suites | 🌐 Cross-Platform Uniform
XmlAttribute* getNextAttribute(XmlAttribute* attribute);
| Property | Value |
|---|---|
| Return Type | XmlAttribute* |
| Modifiers | inline |
| Source Location | App/include/v8xml/XmlElement.h:379 |
| Subsystem | App - Serialization & XML |
How it Works Internally
Executes getNextAttribute within App - Serialization & XML. Coordinates interactions with nextChild.
- 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:
nextChild.
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 getNextAttribute.
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. findAttributeValue
Status: ⚪ Untested in Suites | 🌐 Cross-Platform Uniform
bool findAttributeValue(const XmlTag& _tag, const RBX::Name*& value) const;
| Property | Value |
|---|---|
| Return Type | bool |
| Modifiers | inline const |
| Source Location | App/include/v8xml/XmlElement.h:383 |
| Subsystem | App - Serialization & XML |
How it Works Internally
Executes findAttributeValue within App - Serialization & XML. Coordinates interactions with findAttribute, getValue.
- 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:
findAttribute,getValue.
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 findAttributeValue.
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. findAttributeValue
Status: ⚪ Untested in Suites | 🌐 Cross-Platform Uniform
bool findAttributeValue(const XmlTag& _tag, std::string& value) const;
| Property | Value |
|---|---|
| Return Type | bool |
| Modifiers | inline const |
| Source Location | App/include/v8xml/XmlElement.h:389 |
| Subsystem | App - Serialization & XML |
How it Works Internally
Executes findAttributeValue within App - Serialization & XML. Coordinates interactions with findAttribute, getValue.
- 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:
findAttribute,getValue.
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 findAttributeValue.
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. addChild
Status: ⚪ Untested in Suites | 🌐 Cross-Platform Uniform
XmlElement* addChild(XmlElement* element);
| Property | Value |
|---|---|
| Return Type | XmlElement* |
| Modifiers | inline |
| Source Location | App/include/v8xml/XmlElement.h:399 |
| Subsystem | App - Serialization & XML |
How it Works Internally
child elements
- 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:
pushBackChild.
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 addChild.
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. addChild
Status: ⚪ Untested in Suites | 🌐 Cross-Platform Uniform
XmlElement* addChild(const XmlTag& _tag);
| Property | Value |
|---|---|
| Return Type | XmlElement* |
| Modifiers | None |
| Source Location | App/include/v8xml/XmlElement.h:400 |
| Subsystem | App - Serialization & XML |
How it Works Internally
Executes addChild within App - Serialization & XML. Coordinates interactions with XmlElement. Employs dynamic heap allocation via c++ operator new.
- Control Flow & Execution: Explicit result return.
- Memory Management: Dynamic heap allocation via C++ operator new.
- 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:
XmlElement.
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 addChild.
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. addAttribute
Status: ⚪ Untested in Suites | 🌐 Cross-Platform Uniform
void addAttribute(XmlAttribute* attribute);
| Property | Value |
|---|---|
| Return Type | void |
| Modifiers | inline |
| Source Location | App/include/v8xml/XmlElement.h:409 |
| Subsystem | App - Serialization & XML |
How it Works Internally
Executes addAttribute within App - Serialization & XML. Coordinates interactions with pushBackChild.
- 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:
pushBackChild.
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 addAttribute.
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. getHandleIndex
Status: ⚪ Untested in Suites | 🌐 Cross-Platform Uniform
int getHandleIndex(RBX::InstanceHandle h);
| Property | Value |
|---|---|
| Return Type | int |
| Modifiers | None |
| Source Location | App/include/v8xml/XmlSerializer.h:25 |
| Subsystem | App - Serialization & XML |
How it Works Internally
Executes getHandleIndex within App - Serialization & XML. Coordinates interactions with find, end, 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: Pure computational logic or modifies passed-in parameters/references.
- Key Internal Calls:
find,end,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 getHandleIndex.
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. isValidId
Status: ⚪ Untested in Suites | 🌐 Cross-Platform Uniform
bool isValidId(const std::string& id, const RBX::InstanceHandle& h) const;
| Property | Value |
|---|---|
| Return Type | bool |
| Modifiers | const |
| Source Location | App/include/v8xml/XmlSerializer.h:37 |
| Subsystem | App - Serialization & XML |
How it Works Internally
Executes isValidId within App - Serialization & XML. Coordinates interactions with find, end, getTarget.
- 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,end,getTarget.
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 isValidId.
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. recordId
Status: ⚪ Untested in Suites | 🌐 Cross-Platform Uniform
void recordId(const std::string& id, const RBX::InstanceHandle& h);
| Property | Value |
|---|---|
| Return Type | void |
| Modifiers | None |
| Source Location | App/include/v8xml/XmlSerializer.h:43 |
| Subsystem | App - Serialization & XML |
How it Works Internally
Executes recordId within App - Serialization & XML. Coordinates interactions with RBXASSERT, isValidId.
- 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: Engine invariant assertion check (RBXASSERT).
- State Mutation: Pure computational logic or modifies passed-in parameters/references.
- Key Internal Calls:
RBXASSERT,isValidId.
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 recordId.
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. read
Status: 🧪 Tested | ⚠️ Platform Divergent
void read(void* value, size_t size);
| Property | Value |
|---|---|
| Return Type | void |
| Modifiers | None |
| Source Location | App/v8xml/SerializerBinary.cpp:108 |
| Subsystem | App - Serialization & XML |
How it Works Internally
Executes read within App - Serialization & XML. Coordinates interactions with runtime_error, memcpy.
- 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: C++ exception throw on invalid state or failure; Standard runtime error exception formulation.
- State Mutation: Pure computational logic or modifies passed-in parameters/references.
- Key Internal Calls:
runtime_error,memcpy.
How it is Used in Tests
This function is exercised in 1 test case(s):
SettingsTest::AddingPartUnderSelectionDoesNukeSettings(App.UnitTest/SettingsTest.cpp:211)- Usage Pattern:
Direct Assertion - Assertions Checked:
BOOST_CHECK_EQUAL((RBX::Instances*)NULL, sel->getChildren().read().get()) - Callsite Snippet:
BOOST_CHECK_EQUAL((RBX::Instances*)NULL, sel->getChildren().read().get());
- Usage Pattern:
Behavioral Differences Across Code Files
Divergence Analysis: Alternative platform-specific implementations exist in: Network/Replicator.NewInstanceItem.cpp, App/util/WinHttp.cpp, App/util/WinInet.cpp.
- Alternative Implementation Files:
Network/Replicator.NewInstanceItem.cpp,App/util/WinHttp.cpp,App/util/WinInet.cpp
48. grow
Status: ⚪ Untested in Suites | 🌐 Cross-Platform Uniform
void grow(size_t size);
| Property | Value |
|---|---|
| Return Type | void |
| Modifiers | None |
| Source Location | App/v8xml/SerializerBinary.cpp:130 |
| Subsystem | App - Serialization & XML |
How it Works Internally
Executes grow within App - Serialization & XML. Coordinates interactions with RBXASSERT, newdata, memcpy, get. Employs dynamic heap allocation via c++ operator new.
- Control Flow & Execution: Iterative loop processing.
- Memory Management: Dynamic heap allocation via C++ operator new; RAII scoped heap buffer allocation (boost::scoped_array).
- 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,newdata,memcpy,get,swap. - 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 grow.
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. write
Status: ⚪ Untested in Suites | ⚠️ Platform Divergent
void write(char value);
| Property | Value |
|---|---|
| Return Type | void |
| Modifiers | None |
| Source Location | App/v8xml/SerializerBinary.cpp:147 |
| Subsystem | App - Serialization & XML |
How it Works Internally
Executes write within App - Serialization & XML. Coordinates interactions with grow.
- 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:
grow.
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 write.
Behavioral Differences Across Code Files
Divergence Analysis: Alternative platform-specific implementations exist in: Network/Replicator.NewInstanceItem.cpp, App/util/Darwin/HttpCocoa.mm, App/util/WinHttp.cpp.
- Alternative Implementation Files:
Network/Replicator.NewInstanceItem.cpp,App/util/Darwin/HttpCocoa.mm,App/util/WinHttp.cpp,App/util/WinInet.cpp
50. write
Status: ⚪ Untested in Suites | ⚠️ Platform Divergent
void write(const void* value, size_t size);
| Property | Value |
|---|---|
| Return Type | void |
| Modifiers | None |
| Source Location | App/v8xml/SerializerBinary.cpp:155 |
| Subsystem | App - Serialization & XML |
How it Works Internally
Executes write within App - Serialization & XML. Coordinates interactions with grow, memcpy, get.
- 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:
grow,memcpy,get.
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 write.
Behavioral Differences Across Code Files
Divergence Analysis: Alternative platform-specific implementations exist in: Network/Replicator.NewInstanceItem.cpp, App/util/Darwin/HttpCocoa.mm, App/util/WinHttp.cpp.
- Alternative Implementation Files:
Network/Replicator.NewInstanceItem.cpp,App/util/Darwin/HttpCocoa.mm,App/util/WinHttp.cpp,App/util/WinInet.cpp
51. readData
Status: ⚪ Untested in Suites | 🌐 Cross-Platform Uniform
void readData(std::istream& in, void* data, int size);
| Property | Value |
|---|---|
| Return Type | void |
| Modifiers | static |
| Source Location | App/v8xml/SerializerBinary.cpp:164 |
| Subsystem | App - Serialization & XML |
How it Works Internally
Executes readData within App - Serialization & XML. Coordinates interactions with read, gcount, runtime_error.
- 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: C++ exception throw on invalid state or failure; Standard runtime error exception formulation.
- State Mutation: Pure computational logic or modifies passed-in parameters/references.
- Key Internal Calls:
read,gcount,runtime_error.
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 readData.
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. readChunk
Status: ⚪ Untested in Suites | 🌐 Cross-Platform Uniform
ChunkHeader readChunk(std::istream& in, MemoryInputStream& result);
| Property | Value |
|---|---|
| Return Type | ChunkHeader |
| Modifiers | static |
| Source Location | App/v8xml/SerializerBinary.cpp:172 |
| Subsystem | App - Serialization & XML |
How it Works Internally
Executes readChunk within App - Serialization & XML. Coordinates interactions with readData, reset, get, compressed. Employs dynamic heap allocation via c++ operator new.
- Control Flow & Execution: Conditional branching, Explicit result return.
- Memory Management: Dynamic heap allocation via C++ operator new.
- Concurrency & Thread Safety: Unsynchronized execution (caller must ensure thread-safety if shared).
- Error Handling & Invariants: C++ exception throw on invalid state or failure; Standard runtime error exception formulation.
- State Mutation: Pure computational logic or modifies passed-in parameters/references.
- Key Internal Calls:
readData,reset,get,compressed,size,LZ4_decompress_safe,runtime_error,data.
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 readChunk.
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. writeChunk
Status: ⚪ Untested in Suites | 🌐 Cross-Platform Uniform
void writeChunk(std::ostream& out, const MemoryOutputStream& stream, const char* name, unsigned int flags);
| Property | Value |
|---|---|
| Return Type | void |
| Modifiers | static |
| Source Location | App/v8xml/SerializerBinary.cpp:202 |
| Subsystem | App - Serialization & XML |
How it Works Internally
Executes writeChunk within App - Serialization & XML. Coordinates interactions with strncpy, write, get, LZ4_compressBound.
- 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:
strncpy,write,get,LZ4_compressBound,compressed,FASTLOGS,FASTLOG2.
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 writeChunk.
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. readRaw
Status: ⚪ Untested in Suites | 🌐 Cross-Platform Uniform
void readRaw(MemoryInputStream& stream, T& value);
| Property | Value |
|---|---|
| Return Type | void |
| Modifiers | static |
| Source Location | App/v8xml/SerializerBinary.cpp:232 |
| Subsystem | App - Serialization & XML |
How it Works Internally
Executes readRaw within App - Serialization & XML. Coordinates interactions with read.
- 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:
read.
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 readRaw.
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. writeRaw
Status: ⚪ Untested in Suites | 🌐 Cross-Platform Uniform
void writeRaw(MemoryOutputStream& stream, const T& value);
| Property | Value |
|---|---|
| Return Type | void |
| Modifiers | static |
| Source Location | App/v8xml/SerializerBinary.cpp:237 |
| Subsystem | App - Serialization & XML |
How it Works Internally
Executes writeRaw within App - Serialization & XML. Coordinates interactions with write.
- 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:
write.
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 writeRaw.
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. readString
Status: ⚪ Untested in Suites | 🌐 Cross-Platform Uniform
void readString(MemoryInputStream& stream, std::string& value);
| Property | Value |
|---|---|
| Return Type | void |
| Modifiers | static |
| Source Location | App/v8xml/SerializerBinary.cpp:242 |
| Subsystem | App - Serialization & XML |
How it Works Internally
Executes readString within App - Serialization & XML. Coordinates interactions with readRaw, resize, read.
- 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:
readRaw,resize,read.
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 readString.
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. writeString
Status: ⚪ Untested in Suites | 🌐 Cross-Platform Uniform
void writeString(MemoryOutputStream& stream, const std::string& value);
| Property | Value |
|---|---|
| Return Type | void |
| Modifiers | static |
| Source Location | App/v8xml/SerializerBinary.cpp:253 |
| Subsystem | App - Serialization & XML |
How it Works Internally
Executes writeString within App - Serialization & XML. Coordinates interactions with length, writeRaw, write, c_str.
- 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:
length,writeRaw,write,c_str.
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 writeString.
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. encodeInt
Status: ⚪ Untested in Suites | 🌐 Cross-Platform Uniform
int encodeInt(int value);
| Property | Value |
|---|---|
| Return Type | int |
| Modifiers | static |
| Source Location | App/v8xml/SerializerBinary.cpp:261 |
| Subsystem | App - Serialization & XML |
How it Works Internally
Executes encodeInt within App - Serialization & XML. Coordinates interactions with abs, return.
- 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:
abs,return.
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 encodeInt.
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. decodeInt
Status: ⚪ Untested in Suites | 🌐 Cross-Platform Uniform
int decodeInt(int value);
| Property | Value |
|---|---|
| Return Type | int |
| Modifiers | static |
| Source Location | App/v8xml/SerializerBinary.cpp:267 |
| Subsystem | App - Serialization & XML |
How it Works Internally
Executes decodeInt within App - Serialization & XML. Coordinates interactions with return.
- 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.
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 decodeInt.
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. getInstanceId
Status: ⚪ Untested in Suites | 🌐 Cross-Platform Uniform
int getInstanceId(const std::map<const Instance*, int>& idMap, const Instance* instance);
| Property | Value |
|---|---|
| Return Type | int |
| Modifiers | static |
| Source Location | App/v8xml/SerializerBinary.cpp:272 |
| Subsystem | App - Serialization & XML |
How it Works Internally
Executes getInstanceId within App - Serialization & XML. Coordinates interactions with find, end.
- 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:
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 getInstanceId.
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 109 additional internal and inline functions in this subsystem. All functions are indexed and cross-referenced in the Complete Function Catalog.