Methods

{
  "name": "SVector",
  "namespace": "sofa::type",
  "module": "Sofa.framework.Type",
  "include": "sofa/type/SVector.h",
  "doc": "Same as type::vector, + delimiters on serialization",
  "inherits": [
    "vector"
  ],
  "templates": [],
  "data_fields": [],
  "links": [],
  "methods": [
    {
      "name": "operator=",
      "return_type": "SVector<T> &",
      "params": [
        {
          "name": "x",
          "type": "const Inherit &"
        }
      ],
      "is_virtual": false,
      "is_pure_virtual": false,
      "is_static": false,
      "access": "public"
    },
    {
      "name": "operator=",
      "return_type": "SVector<T> &",
      "params": [
        {
          "name": "v",
          "type": "Inherit &&"
        }
      ],
      "is_virtual": false,
      "is_pure_virtual": false,
      "is_static": false,
      "access": "public"
    },
    {
      "name": "write",
      "return_type": "int &",
      "params": [
        {
          "name": "os",
          "type": "int &"
        }
      ],
      "is_virtual": false,
      "is_pure_virtual": false,
      "is_static": false,
      "access": "public"
    },
    {
      "name": "read",
      "return_type": "int &",
      "params": [
        {
          "name": "in",
          "type": "int &"
        }
      ],
      "is_virtual": false,
      "is_pure_virtual": false,
      "is_static": false,
      "access": "public"
    }
  ],
  "description": "The `SVector` class in the SOFA framework is part of the `sofa::type` namespace and extends the functionality of `type::vector`. It provides additional serialization capabilities with delimiters, ensuring that vectors can be serialized and deserialized correctly with proper formatting. The primary role of `SVector` is to manage vector data types while supporting input/output operations through stream-based methods for reading and writing data in a well-defined format.\n\n**Interactions with other components:**\n- `SVector` inherits from `type::vector`, which means it directly interacts with the base class for its core functionalities. It extends this functionality by adding serialization capabilities.\n- The `write` method outputs vector elements to an output stream, delimiting them appropriately (e.g., using commas and square brackets).\n- The `read` method reads serialized data from an input stream, reconstructing the vector while ensuring that the data is correctly formatted.\n\n**Practical Usage Guidance:**\n- Use `SVector` when you need a standard vector with enhanced serialization features to manage data representation during file I/O operations in simulations or other SOFA-based applications.\n- The class supports basic constructors and assignment operators, allowing for easy instantiation and manipulation of vectors. Specialized methods handle string elements by ensuring they are properly delimited (e.g., using quotes).\n- Serialization is managed through stream-based input/output functions that adhere to a specific format, making it easier to serialize and deserialize vector data.",
  "maths": "The `SVector` class in the SOFA framework extends the functionality of `type::vector`, providing additional serialization capabilities with delimiters. This ensures that vectors can be serialized and deserialized correctly with proper formatting, which is crucial for maintaining data integrity during input/output operations.\n\n### Mathematical Description:\n- **Role in FEM Pipeline:** The `SVector` class itself does not directly contribute to the governing equations or operators of the finite element method (FEM). It serves as a specialized container for vector data types that are often used within the broader SOFA framework, such as storing displacement vectors, force vectors, or other physical quantities.\n\n- **Data Storage and Serialization:** The `SVector` class inherits from `type::vector`, which is a standard vector implementation. However, it adds serialization capabilities through its `write` and `read` methods:\n  - The `write` method outputs the vector elements to an output stream with delimiters (e.g., commas and square brackets). This ensures that the serialized data can be easily parsed and reconstructed.\n  - The `read` method reads serialized data from an input stream, reconstructing the vector while ensuring proper formatting. For example, when reading string elements, it ensures they are properly delimited using quotes.\n\n- **Interactions with Other Components:**\n  - As part of the SOFA framework, `SVector` interacts directly with other components that require vector data storage and manipulation. It can be used to store various physical quantities such as displacements, forces, or constraints within the simulation pipeline.\n  - The serialization capabilities are particularly useful in scenarios where data needs to be saved and loaded between different parts of a simulation, ensuring consistent representation of vectors across these operations.\n\n### Numerical Methods:\n- **Discretization Choices:** `SVector` does not encode any specific numerical methods or discretization choices directly. Instead, it provides a container for storing discrete values that can be used in various numerical algorithms within the SOFA framework.\n\n### Variational / Lagrangian Mechanics Framework:\n- The `SVector` class itself is not part of the core variational or Lagrangian mechanics framework. However, it supports these frameworks by providing robust storage and serialization capabilities for vectors that are often used in variational formulations and FEM simulations.\n\nIn summary, `SVector` plays a supporting role in the SOFA framework, enhancing vector data management with serialization features, which is essential for maintaining consistency during input/output operations within complex simulations.",
  "abstract": "`SVector` extends `type::vector` with serialization capabilities using delimiters for proper formatting during input/output operations in SOFA simulations.",
  "sheet": "# SVector\n\n**Overview:**\n\nThe `SVector` class is an extension of the standard vector implementation (`type::vector`) within the SOFA framework. It provides enhanced serialization features, ensuring that vectors can be serialized and deserialized with proper formatting using delimiters.\n\n**Parameters and Data:*\n\nThere are no significant data fields exposed by this component beyond those inherited from `type::vector`. The primary functionality is provided through its methods for reading and writing vector elements to streams.\n\n**Dependencies and Connections:**\n\n`SVector` inherits from the base class `type::vector`, which provides the core functionalities of a standard vector. It does not have any specific dependencies on other SOFA components but can be used in conjunction with various simulation-related classes that require robust vector data management.\n\n**Practical Notes:*\n\nUse `SVector` when you need to manage vector data types with enhanced serialization capabilities, ensuring proper formatting during input/output operations. The class supports basic constructors and assignment operators for easy instantiation and manipulation of vectors."
}