docs: document Rust Standard Row support

Author: chaokunyang

README.md

@@ -802,6 +802,7 @@ int secondScore = scores.getInt32(1);
 For Java imports, nested structs, arrays/maps, Arrow integration, and partial
 deserialization, see the [Java row-format guide](docs/row-format/java.md),
 [Python row-format guide](docs/row-format/python.md),
+[C++ row-format guide](docs/row-format/cpp.md),
 [Rust row-format guide](docs/row-format/rust.md), and
 [row-format specification](docs/specification/row_format_spec.md).
 

docs/introduction/product-model.md

@@ -24,12 +24,12 @@ contract you need, then choose a runtime API.
 
 ## Serialization products
 
-| Product                                  | Data model                           | Interoperability boundary                                                                             |
-| ---------------------------------------- | ------------------------------------ | ----------------------------------------------------------------------------------------------------- |
-| Binary Object Serialization: xlang mode  | Portable object graphs               | Shared wire format across supported runtimes                                                          |
-| Binary Object Serialization: native mode | Runtime-native object graphs         | Same runtime family only                                                                              |
+| Product                                  | Data model                           | Interoperability boundary                                                       |
+| ---------------------------------------- | ------------------------------------ | ------------------------------------------------------------------------------- |
+| Binary Object Serialization: xlang mode  | Portable object graphs               | Shared wire format across supported runtimes                                    |
+| Binary Object Serialization: native mode | Runtime-native object graphs         | Same runtime family only                                                        |
 | Row Format                               | Random-access binary rows            | Standard Row is shared by Java, Python, C++, and Rust; Compact Row is Java-only |
-| Fory JSON                                | Standard JSON mapped to Java objects | Java API with text interoperability                                                                   |
+| Fory JSON                                | Standard JSON mapped to Java objects | Java API with text interoperability                                             |
 
 Xlang and native are sibling modes of Binary Object Serialization. Row Format and Fory JSON are
 separate products; neither is a third object-serialization mode.

docs/introduction/support-matrix.md

@@ -27,7 +27,7 @@ does not imply support for every Fory product.
 | Xlang object serialization  | Java, Python, C++, Go, Rust, JavaScript/TypeScript, C#, Swift, Dart, Scala, Kotlin | One shared xlang wire format                             |
 | Native object serialization | Java, Python, C++, Go, Rust, Scala, Kotlin                                         | Same runtime family only                                 |
 | Standard Row Format         | Java, Python, C++, Rust                                                            | Shared Standard Row layout                               |
-| Compact Row Format          | Java                                                                               | Java-only and currently unstable                         |
+| Compact Row Format          | Java                                                                               | Java-only compact layout                                 |
 | Fory JSON                   | Java                                                                               | Standard JSON text                                       |
 | Fory compiler output        | Java, Python, C++, Go, Rust, JavaScript/TypeScript, C#, Swift, Dart, Scala, Kotlin | Generated models use supported Fory APIs                 |
 | Fory gRPC                   | Java, Python, C++, Go, Rust, JavaScript/TypeScript, C#, Dart, Scala, Kotlin        | Peers must use matching generated Fory service contracts |

docs/json/index.md

@@ -59,3 +59,10 @@ Jackson object mapping:
 
 Circular graphs eventually fail `maxDepth`; they are not reconstructed. Use Fory core's binary
 native or xlang protocol when reference identity or cycles are required.
+
+## Related Java guides
+
+For binary serialization, start with [Java Object Serialization](../object-serialization/java/index.md)
+and choose [xlang](../object-serialization/java/xlang.md) or
+[native](../object-serialization/java/native.md). Binary builder options are documented separately
+in [Java Configuration](../object-serialization/java/configuration.md).

docs/object-serialization/rust/core-api.md

@@ -152,12 +152,9 @@ fory = { version = "1.5.0", features = ["chrono"] }
 
 ### Custom Types
 
-| Macro                   | Description                           |
-| ----------------------- | ------------------------------------- |
-| `#[derive(ForyStruct)]` | Object graph serialization            |
-| `#[derive(ForyRow)]`    | Standard Row Format for named structs |
-
-`ForyRow` has a separate type set and returns borrowed field views. Row reads and field access use `Result` to report invalid row data. See [Row Format](../../row-format/rust.md) for supported types, nullability, and examples.
+Use `#[derive(ForyStruct)]` for object graph serialization. The separate
+[Rust Row Format guide](../../row-format/rust.md) documents `#[derive(ForyRow)]` and its supported
+type set.
 
 ## Serialization APIs
 
@@ -207,7 +204,6 @@ all supported carriers, and registration.
 
 ## Performance Tips
 
-- **Selective Zero-Copy Access**: Row Format returns borrowed views for direct field and element access
 - **Buffer Pre-allocation**: Minimizes memory allocations during serialization
 - **Compact Encoding**: Variable-length encoding for space efficiency
 - **Little-Endian**: Optimized for modern CPU architectures

docs/object-serialization/rust/index.md

@@ -19,7 +19,7 @@ license: |
   limitations under the License.
 ---
 
-**Apache Fory™** is a high-performance multi-language serialization framework. The Rust implementation uses compile-time code generation for object serialization and borrowed views for zero-copy Row Format access.
+**Apache Fory™** is a high-performance multi-language serialization framework. The Rust implementation uses compile-time code generation for object serialization.
 
 The Rust implementation provides versatile and high-performance serialization with automatic memory management and compile-time type safety. It supports both xlang mode for cross-language payloads and native mode for Rust-only payloads.
 
@@ -32,7 +32,6 @@ The Rust implementation provides versatile and high-performance serialization wi
 - **Circular references**: Automatic tracking of shared and circular references with `Rc`/`Arc` and weak pointers
 - **Polymorphic**: Serialize trait objects with `Box<dyn Trait>`, `Rc<dyn Trait>`, and `Arc<dyn Trait>`
 - **Schema evolution**: Compatible mode for independent schema changes
-- **Two formats**: Object graph serialization and the Standard Row Format shared with Java, C++, and Python
 
 ## Crates
 
@@ -156,15 +155,6 @@ fn main() -> Result<(), Error> {
 - Schema evolution with compatible mode
 - Graph-like data structures with circular references
 
-### Standard Row Format
-
-- High-throughput data processing
-- Analytics workloads requiring fast field access
-- Memory-constrained environments
-- Real-time data streaming applications
-- Zero-copy field and collection access
-- Standard Row Format interchange with Java, C++, and Python
-
 ## Next Steps
 
 - [Configuration](configuration.md) - Fory builder options and modes

docs/row-format/compact.md

@@ -19,8 +19,8 @@ license: |
   limitations under the License.
 ---
 
-Compact Row is a Java-only row encoding that reduces fixed-slot and null-bitmap overhead. It is
-currently unstable and is not wire-compatible with Standard Row.
+Compact Row is a Java-only row encoding that reduces fixed-slot and null-bitmap overhead. It is not
+wire-compatible with Standard Row.
 
 ## Create a compact encoder
 
@@ -44,7 +44,7 @@ Reuse the encoder within one thread. Create separate encoders for concurrent thr
 - The null bitmap is omitted when no field is nullable.
 - Fixed-size nested structs can be stored inline.
 
-Choose Compact Row only when every reader is Java and the space reduction justifies using an
-unstable format. Use [Standard Row](standard.md) for Java/Python/C++/Rust interchange.
+Choose Compact Row only when every reader is Java and the space reduction justifies the
+Java-specific layout. Use [Standard Row](standard.md) for Java/Python/C++/Rust interchange.
 
 See the [Row Format specification](../specification/row_format_spec.md) for the exact binary layout.

docs/row-format/index.md

@@ -25,10 +25,10 @@ in-memory data processing.
 
 ## Choose a row family
 
-| Family                      | Runtime support         | Compatibility                                 |
-| --------------------------- | ----------------------- | --------------------------------------------- |
-| [Standard Row](standard.md) | Java, Python, C++, Rust | Shared Standard Row layout                    |
-| [Compact Row](compact.md)   | Java                    | Java-only, space-oriented, currently unstable |
+| Family                      | Runtime support         | Compatibility                    |
+| --------------------------- | ----------------------- | -------------------------------- |
+| [Standard Row](standard.md) | Java, Python, C++, Rust | Shared Standard Row layout       |
+| [Compact Row](compact.md)   | Java                    | Java-only, space-oriented layout |
 
 Use Binary Object Serialization when the goal is complete object reconstruction, references, or
 general application messaging. Use Row Format when a workload reads selected fields, nested arrays,

docs/row-format/rust.md

@@ -98,6 +98,7 @@ fn main() -> Result<(), Error> {
 `ArrayView::iter` and `IntoIterator for &ArrayView` read elements on demand through the same checked path as `get`. Each item is a `Result`, so malformed data is reported when that element is visited.
 
 `MapView` exposes `len`, `is_empty`, `key(index)`, and `value(index)`. Its `keys()` and `values()` array views remain available for independent iteration.
+Call `to_btree_map()` only when an owned lookup structure is more useful than indexed access; it materializes the map from the borrowed key and value views.
 
 Struct, array, and map views are cheap `Copy` and `Clone` values. The `RowView` trait provides `as_bytes()`, which returns the exact encoded slice bound to the view, and `encoded_len()`, which returns its length. A nested view returns only its size-delimited child bytes.
 

docs/row-format/standard.md

@@ -51,7 +51,7 @@ or complete object reconstruction as its primary access pattern.
 | Java    | Compatible                 | [Java](java.md)     | Arrow conversion; interface and extension-type mapping |
 | Python  | Compatible                 | [Python](python.md) | PyArrow schema and table conversion                    |
 | C++     | Compatible                 | [C++](cpp.md)       | Native row readers and writers                         |
-| Rust    | Compatible                 | [Rust](rust.md)     | Borrowed struct, array, and map views                   |
+| Rust    | Compatible                 | [Rust](rust.md)     | Borrowed struct, array, and map views                  |
 
 Use the runtime guides for installation, schema construction, encoding, random
 access, partial reads, and language-specific integrations.