{"id":28299003,"url":"https://github.com/geeknoid/dst-factory","last_synced_at":"2026-03-16T02:29:21.863Z","repository":{"id":294793932,"uuid":"988096709","full_name":"geeknoid/dst-factory","owner":"geeknoid","description":"A crate that provides C-like flexible array members in Rust.","archived":false,"fork":false,"pushed_at":"2026-02-17T21:01:12.000Z","size":140,"stargazers_count":1,"open_issues_count":0,"forks_count":0,"subscribers_count":1,"default_branch":"main","last_synced_at":"2026-02-17T22:39:07.241Z","etag":null,"topics":["dst","memory-allocation","rust"],"latest_commit_sha":null,"homepage":"https://crates.io/crates/dst-factory","language":"Rust","has_issues":true,"has_wiki":null,"has_pages":null,"mirror_url":null,"source_name":null,"license":"mit","status":null,"scm":"git","pull_requests_enabled":true,"icon_url":"https://github.com/geeknoid.png","metadata":{"files":{"readme":"README.md","changelog":"CHANGELOG.md","contributing":null,"funding":null,"license":"LICENSE","code_of_conduct":null,"threat_model":null,"audit":null,"citation":null,"codeowners":null,"security":null,"support":null,"governance":null,"roadmap":null,"authors":null,"dei":null,"publiccode":null,"codemeta":null,"zenodo":null,"notice":null,"maintainers":null,"copyright":null,"agents":null,"dco":null,"cla":null}},"created_at":"2025-05-22T03:47:42.000Z","updated_at":"2026-02-17T20:09:21.000Z","dependencies_parsed_at":"2025-09-14T23:25:09.840Z","dependency_job_id":"8ca17d5d-e2f4-4f1c-89f6-8c71b560e34a","html_url":"https://github.com/geeknoid/dst-factory","commit_stats":null,"previous_names":["geeknoid/tail-extend","geeknoid/dst-factory"],"tags_count":11,"template":false,"template_full_name":null,"purl":"pkg:github/geeknoid/dst-factory","repository_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/geeknoid%2Fdst-factory","tags_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/geeknoid%2Fdst-factory/tags","releases_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/geeknoid%2Fdst-factory/releases","manifests_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/geeknoid%2Fdst-factory/manifests","owner_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners/geeknoid","download_url":"https://codeload.github.com/geeknoid/dst-factory/tar.gz/refs/heads/main","sbom_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/geeknoid%2Fdst-factory/sbom","scorecard":null,"host":{"name":"GitHub","url":"https://github.com","kind":"github","repositories_count":286080680,"owners_count":30279777,"icon_url":"https://github.com/github.png","version":null,"created_at":"2022-05-30T11:31:42.601Z","updated_at":"2026-03-08T20:45:49.896Z","status":"ssl_error","status_checked_at":"2026-03-08T20:45:49.525Z","response_time":56,"last_error":"SSL_connect returned=1 errno=0 peeraddr=140.82.121.6:443 state=error: unexpected eof while reading","robots_txt_status":"success","robots_txt_updated_at":"2025-07-24T06:49:26.215Z","robots_txt_url":"https://github.com/robots.txt","online":false,"can_crawl_api":true,"host_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub","repositories_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories","repository_names_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repository_names","owners_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners"}},"keywords":["dst","memory-allocation","rust"],"created_at":"2025-05-23T06:15:49.398Z","updated_at":"2026-03-16T02:29:21.856Z","avatar_url":"https://github.com/geeknoid.png","language":"Rust","funding_links":[],"categories":[],"sub_categories":[],"readme":"# dst-factory\n\n[![crate.io](https://img.shields.io/crates/v/dst-factory.svg)](https://crates.io/crates/dst-factory)\n[![docs.rs](https://docs.rs/dst-factory/badge.svg)](https://docs.rs/dst-factory)\n[![CI](https://github.com/geeknoid/dst-factory/workflows/main/badge.svg)](https://github.com/geeknoid/dst-factory/actions)\n[![Coverage](https://codecov.io/gh/geeknoid/dst-factory/graph/badge.svg?token=FCUG0EL5TI)](https://codecov.io/gh/geeknoid/dst-factory)\n[![Minimum Supported Rust Version 1.90](https://img.shields.io/badge/MSRV-1.90-blue.svg)]()\n[![License](https://img.shields.io/badge/license-MIT-blue.svg)](./LICENSE)\n\n* [Summary](#summary)\n* [Why Should You Care?](#why-should-you-care)\n* [Where to Use DSTs?](#where-to-use-dsts)\n* [Examples](#examples)\n* [Smart Pointers](#smart-pointers)\n* [Attribute Features](#attribute-features)\n  * [Trait Implementations](#trait-implementations)\n  * [Zero-Initialized Buffers](#zero-initialized-buffers)\n  * [Serde Support](#serde-support)\n* [Other Features](#other-features)\n* [Error Conditions](#error-conditions)\n* [Acknowledgments](#acknowledgments)\n\n## Summary\n\n\u003c!-- cargo-rdme start --\u003e\n\nRich support to safely create instances of [Dynamically Sized Types](https://doc.rust-lang.org/reference/dynamically-sized-types.html).\n\nThis crate lets you allocate variable data inline at the end of a struct. If you have a\nstruct that gets allocated on the heap and has some variable-length data associated with it\n(like a string or an array), then you can allocate this data directly inline with the struct.\nThis saves memory by avoiding the need for a pointer and a separate allocation, and saves CPU\ncycles by eliminating the need for indirection when accessing the data.\n\nRust supports the notion of [Dynamically Sized Types](https://doc.rust-lang.org/reference/dynamically-sized-types.html), known as DSTs,\nwhich are types that have a size not known at compile time. DSTs are perfect to implement\nflexible array members. But unfortunately, Rust doesn't provide an out-of-the-box way to allocate\ninstances of such types. This is where this crate comes in.\n\nYou can apply the #[[`macro@make_dst_factory`]] attribute to your DST structs, which generates factory\nfunctions that let you easily and safely create instances of your DSTs.\n\n## Why Should You Care?\n\nDynamically sized types aren't for everyone. You can't use them as local variables\nor put them in arrays or vectors, so they can be inconvenient to use. However, their value\nlies in situations where you have a lot of heap-allocated objects, as they can substantially\nreduce the memory footprint of your application. If you're building graphs, trees, or other\ndynamic data structures, you can often leverage DSTs to keep your individual nodes smaller\nand more efficient.\n\n## Where to Use DSTs?\n\nIt can be hard or tedious to discover where in your codebase there are opportunities to use DSTs.\nYou can give the following prompt to your favorite AI to have it find candidate structs that\ncan be upgraded to a DST.\n\n```text\nAnalyze this Rust codebase for DST (Dynamically Sized Type) optimization opportunities using the dst_factory crate pattern.\n\nA DST struct has one trailing unsized field that is co-located with the struct header in a single allocation (behind Arc, Box, or Rc), eliminating one heap indirection. There are three forms:\n\n - String field → trailing str (eliminates the String's heap buffer)\n - Vec\u003cT\u003e field → trailing [T] (eliminates the Vec's heap buffer)\n - Box\u003cdyn Trait\u003e field → trailing dyn Trait (eliminates the Box's heap allocation and pointer indirection)\n\nA struct is a candidate if ALL of these are true:\n\n 1. It has at least one String, Vec\u003cT\u003e, or Box\u003cdyn Trait\u003e field\n 2. It is used behind Arc\u003cT\u003e, Box\u003cT\u003e, or Rc\u003cT\u003e — NOT stored inline in a Vec, HashMap, array, or by value on the stack\n 3. The candidate field is not resized, replaced, or swapped after construction. In-place mutation of elements (e.g., writing to [u8] slots, calling \u0026mut self methods on a dyn Trait) is fine — only\noperations that change the length or swap the entire value are disqualifying (e.g., push(), pop(), clear(), resize(), reassigning the field to a new String/Vec/Box\u003cdyn\u003e)\n\nA struct with multiple candidate fields is still a valid candidate — the user picks one field as the trailing unsized tail, the others stay as-is. When listing candidates, note ALL eligible tail fields and\nrecommend which one to pick (typically the largest or most frequently populated).\n\nFor each crate, systematically:\n\n 1. Find all struct definitions (both pub and private) that have String, Vec\u003cT\u003e, or Box\u003cdyn Trait\u003e fields\n 2. For each, grep for Arc\u003cStructName\u003e, Box\u003cStructName\u003e, Vec\u003cStructName\u003e to determine usage pattern\n 3. Check whether candidate fields are resized, replaced, or swapped after construction (in-place element mutation is OK)\n 4. Report: file path, full struct definition, all candidate tail fields, usage pattern (Arc/Box/Vec/value), mutability assessment, and recommended tail choice\n\nExclude:\n\n - Structs stored in Vec\u003cT\u003e or HashMap values (DSTs are !Sized)\n - Structs where the candidate field is resized or replaced after construction (e.g., push(), clear(), field reassignment)\n - Structs not behind Arc/Box/Rc (no allocation to optimize)\n - Test-only structs\n\nOutput format per candidate:\n\n ### StructName\n File: path/to/file.rs:line\n Arc/Box usage: N sites (list key files)\n Candidate tail fields:\n   - field_name: Type → unsized_type (recommended: yes/no, reason)\n   - field_name: Type → unsized_type\n Resized/replaced after construction: no (cite evidence) / yes (disqualifying method)\n Volume: how often constructed per request/operation\n Savings: 1 allocation per instance × volume\n```\n\n## Examples\n\nHere's an example using an array as the last field of a struct:\n\n```rust\nuse dst_factory::make_dst_factory;\n\n#[make_dst_factory]\nstruct User {\n    age: u32,\n    signing_key: [u8],\n}\n\n// allocate one user with a 4-byte key\nlet a = User::build(33, [0, 1, 2, 3]);\n\n// allocate another user with a 5-byte key\nlet b = User::build_from_slice(33, \u0026[0, 1, 2, 3, 4]);\n\n// allocate another user, this time using an iterator\nlet v = vec![0, 1, 2, 3, 4];\nlet c = User::build(33, v.iter().copied());\n\n// destructure this user and compare its key to the vector\n// this has the advantage of iterating over u8, not \u0026u8 or \u0026mut u8.\nlet (_age, signing_key) = User::destructure(c);\nassert!(signing_key.eq(v.into_iter()));\n```\nHere's another example, this time using a string as the last field of a struct:\n\n```rust\nuse dst_factory::make_dst_factory;\n\n#[make_dst_factory]\nstruct User {\n    age: u32,\n    name: str,\n}\n\n// allocate one user with a 5-character string\nlet a = User::build(33, \"Alice\");\n\n// allocate another user with a 3-character string\nlet b = User::build(33, \"Bob\");\n```\nAnd finally, here's an example using a trait object as the last field of a struct:\n\n```rust\nuse dst_factory::make_dst_factory;\n\n// a trait we'll use in our DST\ntrait NumberProducer {\n    fn get_number(\u0026self) -\u003e u32;\n}\n\n// an implementation of the trait we're going to use\nstruct FortyTwoProducer;\nimpl NumberProducer for FortyTwoProducer {\n    fn get_number(\u0026self) -\u003e u32 {\n        42\n    }\n}\n\n// another implementation of the trait we're going to use\nstruct TenProducer;\nimpl NumberProducer for TenProducer {\n    fn get_number(\u0026self) -\u003e u32 {\n        10\n    }\n}\n\n#[make_dst_factory]\nstruct Node {\n    count: u32,\n    producer: dyn NumberProducer,\n}\n\n// allocate an instance with one implementation of the trait\nlet a = Node::build(33, FortyTwoProducer{});\nassert_eq!(42, a.producer.get_number());\n\n// allocate an instance with another implementation of the trait\nlet b = Node::build(33, TenProducer{});\nassert_eq!(10, b.producer.get_number());\n```\n\nBecause DSTs don't have a known size at compile time, you can't store them on the stack,\nand you can't pass them by value. As a result of these constraints, the factory functions\nreturn smart-pointer-wrapped instances of the structs.\n\n## Smart Pointers\n\nThe macro generates factory functions for three smart pointer types:\n\n| Pointer | Factory suffix | Use case |\n|---------|---------------|----------|\n| [`Box\u003cT\u003e`] | *(none)* | Unique ownership |\n| [`Arc\u003cT\u003e`](std::sync::Arc) | `_arc` | Shared ownership, thread-safe (atomic refcount) |\n| [`Rc\u003cT\u003e`](std::rc::Rc) | `_rc` | Shared ownership, single-threaded (non-atomic refcount) |\n\n```rust\nuse dst_factory::make_dst_factory;\nuse std::sync::Arc;\nuse std::rc::Rc;\n\n#[make_dst_factory]\nstruct User {\n    age: u32,\n    name: str,\n}\n\n// Unique ownership\nlet boxed: Box\u003cUser\u003e = User::build(33, \"Alice\");\n\n// Thread-safe shared ownership\nlet shared: Arc\u003cUser\u003e = User::build_arc(33, \"Bob\");\nlet clone = Arc::clone(\u0026shared);\nassert_eq!(\u0026clone.name, \"Bob\");\n\n// Single-threaded shared ownership\nlet local: Rc\u003cUser\u003e = User::build_rc(33, \"Carol\");\nlet clone = Rc::clone(\u0026local);\nassert_eq!(\u0026clone.name, \"Carol\");\n\n// Convert an existing Box\u003cUser\u003e into Arc\u003cUser\u003e or Rc\u003cUser\u003e\nlet boxed: Box\u003cUser\u003e = User::build(33, \"Dora\");\nlet shared: Arc\u003cUser\u003e = User::into_arc(boxed);\nassert_eq!(\u0026shared.name, \"Dora\");\n```\n\nAs shown above, in addition to the factory methods, the macro always generates the `into_arc` and `into_rc`\nassociated functions that convert a `Box\u003cSelf\u003e` into `Arc\u003cSelf\u003e` or `Rc\u003cSelf\u003e` while\npreserving the inline DST layout.\n\n## Attribute Features\n\nThe common use case for the #[[`macro@make_dst_factory`]] attribute is to not pass any arguments.\nThis results in functions called `build`, `build_arc`, and `build_rc` when using a string\nor dynamic trait as the last field of the struct, and additionally `build_from_slice`,\n`build_arc_from_slice`, `build_rc_from_slice`, and `destructure` when using an array as the\nlast field of the struct.\n\nThe generated functions are private by default and have the following approximate signatures:\n\n```rust\n// for slices\nfn build\u003cG\u003e(field1, field2, ..., last_field: G) -\u003e Box\u003cSelf\u003e\nwhere\n    G: IntoIterator\u003cItem = last_field_type\u003e,\n    \u003cG as IntoIterator\u003e::IntoIter: ExactSizeIterator,\n\nfn build_from_slice(field1, field2, ..., last_field: \u0026[last_field_type]) -\u003e Box\u003cSelf\u003e\nwhere\n    last_field_type: Copy + Sized;\n\nfn build_arc\u003cG\u003e(field1, field2, ..., last_field: G) -\u003e Arc\u003cSelf\u003e\nwhere\n    G: IntoIterator\u003cItem = last_field_type\u003e,\n    \u003cG as IntoIterator\u003e::IntoIter: ExactSizeIterator,\n\nfn build_arc_from_slice(field1, field2, ..., last_field: \u0026[last_field_type]) -\u003e Arc\u003cSelf\u003e\nwhere\n    last_field_type: Copy + Sized;\n\nfn build_rc\u003cG\u003e(field1, field2, ..., last_field: G) -\u003e Rc\u003cSelf\u003e\nwhere\n    G: IntoIterator\u003cItem = last_field_type\u003e,\n    \u003cG as IntoIterator\u003e::IntoIter: ExactSizeIterator,\n\nfn build_rc_from_slice(field1, field2, ..., last_field: \u0026[last_field_type]) -\u003e Rc\u003cSelf\u003e\nwhere\n    last_field_type: Copy + Sized;\n\nfn destructure(this: Box\u003cSelf\u003e) -\u003e (Type1, Type2, ..., SelfIter);\n\n// when zeroable flag is set (slice tails only, requires bytemuck)\nfn build_zeroed(field1, field2, ..., len: usize) -\u003e Box\u003cSelf\u003e\nwhere\n    last_field_type: bytemuck::Zeroable;\n\nfn build_arc_zeroed(field1, field2, ..., len: usize) -\u003e Arc\u003cSelf\u003e\nwhere\n    last_field_type: bytemuck::Zeroable;\n\nfn build_rc_zeroed(field1, field2, ..., len: usize) -\u003e Rc\u003cSelf\u003e\nwhere\n    last_field_type: bytemuck::Zeroable;\n\n// for strings\nfn build(field1, field2, ..., last_field: impl AsRef\u003cstr\u003e) -\u003e Box\u003cSelf\u003e;\nfn build_arc(field1, field2, ..., last_field: impl AsRef\u003cstr\u003e) -\u003e Arc\u003cSelf\u003e;\nfn build_rc(field1, field2, ..., last_field: impl AsRef\u003cstr\u003e) -\u003e Rc\u003cSelf\u003e;\n\n// for trait objects\nfn build(field1, field2, ..., last_field: G) -\u003e Box\u003cSelf\u003e\nwhere\n    G: TraitName + Sized;\n\nfn build_arc(field1, field2, ..., last_field: G) -\u003e Arc\u003cSelf\u003e\nwhere\n    G: TraitName + Sized;\n\nfn build_rc(field1, field2, ..., last_field: G) -\u003e Rc\u003cSelf\u003e\nwhere\n    G: TraitName + Sized;\n\n// generated for all DSTs\nfn into_arc(this: Box\u003cSelf\u003e) -\u003e Arc\u003cSelf\u003e;\nfn into_rc(this: Box\u003cSelf\u003e) -\u003e Rc\u003cSelf\u003e;\n```\n\nThe attribute lets you control the name of the generated functions, their\nvisibility, and whether to generate code for the `no_std` environment, along with\nwhich traits to automatically implement for your type. The general grammar is:\n\n```rust\n#[make_dst_factory(\n    \u003cbase_factory_name\u003e\n    [, destructurer=\u003cdestructurer_name\u003e]\n    [, iterator=\u003citerator_name\u003e]\n    [, generic=\u003cgeneric_name\u003e]\n    [, \u003cvisibility\u003e]\n    [, no_std]\n    [, deserialize]\n    [, clone]\n    [, debug]\n    [, eq]\n    [, ord]\n    [, hash]\n    [, zeroable]\n)]\n```\n\nSome examples:\n\n```rust\n// Make all generated functions public.\n#[make_dst_factory(pub)]\n\n// Custom base name for the generated functions giving `create`, `create_from_slice`, `create_arc`, `create_arc_from_slice`,\n// `create_rc`, and `create_rc_from_slice`.\n#[make_dst_factory(create)]\n\n// Custom destructurer name.\n#[make_dst_factory(create, destructurer = destroy)]\n\n// Public functions with custom name.\n#[make_dst_factory(create, pub)]\n\n// Support the `no_std` environment.\n#[make_dst_factory(create, no_std)]\n\n// Custom generic type name.\n#[make_dst_factory(create, no_std, generic=X)]\n```\n\n### Trait Implementations\n\nRust's standard `#[derive(...)]` often doesn't work for DST structs. The #[[`macro@make_dst_factory`]] attribute provides\nflags to generate these trait implementations:\n\n| Flag | Trait(s) generated | Notes |\n|------|-------------------|-------|\n| `clone` | `Clone` for `Box\u003cT\u003e` | Deep copy via factory function |\n| `debug` | `Debug` for the struct | Named fields or tuple formatting |\n| `eq` | `PartialEq` and `Eq` for the struct | Compares all fields |\n| `ord` | `PartialOrd` and `Ord` for the struct | Compares all fields lexicographically |\n| `hash` | `Hash` for the struct | Hashes all fields |\n\nWhen the last field of the struct is a `dyn Trait`, the generated `where` clauses require the trait object to\nimplement the relevant trait (e.g. `dyn MyTrait: Debug`). The `clone` flag is the\nexception; it is not supported for `dyn Trait` since there is no way to clone\na concrete type through a trait object reference.\n\n```rust\nuse dst_factory::make_dst_factory;\n\n#[make_dst_factory(clone, debug, eq, ord, hash)]\nstruct Message {\n    id: u32,\n    text: str,\n}\n\nlet msg = Message::build(1, \"hello\");\nlet cloned = msg.clone();\nassert_eq!(msg, cloned);\nassert_eq!(format!(\"{:?}\", \u0026*msg), \"Message { id: 1, text: \\\"hello\\\" }\");\n```\n\n### Zero-Initialized Buffers\n\nWhen the last struct field is a `[T]`, the `zeroable` flag generates `build_zeroed`, `build_arc_zeroed`,\nand `build_rc_zeroed` factories that allocate the DST with a zero-initialized slice of a\ngiven length.\n\n```rust\nuse dst_factory::make_dst_factory;\n\n#[make_dst_factory(zeroable)]\nstruct Buffer {\n    cursor: usize,\n    data: [u8],\n}\n\n// Allocate a 1MB buffer with zero-initialized payload — no per-element initialization.\nlet buf = Buffer::build_zeroed(0, 1_000_000);\nassert_eq!(buf.data.len(), 1_000_000);\nassert!(buf.data.iter().all(|\u0026b| b == 0));\n```\n\n### Serde Support\n\nDST structs work naturally with serde's `#[derive(Serialize)]`, since serialization\nonly requires a reference. However, `#[derive(Deserialize)]` does not work with DSTs,\nso special support is needed instead.\n\nPassing the `deserialize` flag in the attribute generates a\n[`Deserialize`](https://docs.rs/serde/latest/serde/trait.Deserialize.html) implementation\nfor `Box\u003cT\u003e`.\n\n```rust\nuse dst_factory::make_dst_factory;\nuse serde::Serialize;\n\n#[derive(Serialize)]\n#[make_dst_factory(deserialize)]\nstruct Message {\n    id: u32,\n    text: str,\n}\n\n// Serialize\nlet msg = Message::build(1, \"hello\");\nlet json = serde_json::to_string(\u0026*msg).unwrap();\n\n// Deserialize\nlet restored: Box\u003cMessage\u003e = serde_json::from_str(\u0026json).unwrap();\nassert_eq!(restored.id, 1);\nassert_eq!(\u0026restored.text, \"hello\");\n```\n\nRust's orphan rules prevent implementing `Deserialize` for `Arc\u003cT\u003e` or `Rc\u003cT\u003e`.\nInstead, the `deserialize` flag generates helper functions `deserialize_arc` and\n`deserialize_rc` that can be used with serde's `#[serde(deserialize_with = \"...\")]`\nattribute:\n\n```rust\nuse dst_factory::make_dst_factory;\nuse serde::{Serialize, Deserialize};\nuse std::sync::Arc;\nuse std::rc::Rc;\n\n#[derive(Serialize)]\n#[make_dst_factory(deserialize)]\nstruct Message {\n    id: u32,\n    text: str,\n}\n\n#[derive(Serialize, Deserialize)]\nstruct Dashboard {\n    #[serde(deserialize_with = \"Message::deserialize_arc\")]\n    shared_msg: Arc\u003cMessage\u003e,\n\n    #[serde(deserialize_with = \"Message::deserialize_rc\")]\n    local_msg: Rc\u003cMessage\u003e,\n}\n```\n\nDeserialization is not supported when the last field of the struct is a `dyn Trait`\nsince there is no way to reconstruct the concrete type from serialized data.\n\n## Other Features\n\nYou can use the #[[`macro@make_dst_factory`]] attribute on structs with the normal Rust\nrepresentation or C representation (`#[repr(C)]`), with any padding and alignment\nspecification. See the Rust reference on [Type Layout](https://doc.rust-lang.org/reference/type-layout.html)\nfor more details.\n\n## Error Conditions\n\nThe #[[`macro@make_dst_factory`]] attribute produces a compile-time error if:\n\n- It's applied to anything other than a regular struct or a tuple struct.\n- Its arguments are malformed (e.g., incorrect visibility keyword, too many arguments, etc.).\n- The struct has no fields.\n- The last field of the struct is not a slice (`[T]`), a string (`str`), or a trait object (`dyn Trait`).\n- The resulting struct exceeds the maximum size allowed of `isize::MAX`.\n- The `deserialize` or `clone` flags are used on a struct whose last field is a trait object.\n- The `zeroable` flag is used on a struct whose last field is not a slice (`[T]`).\n\n## Acknowledgments\n\nMany thanks to \u003chttps://github.com/scottmcm\u003e for his invaluable help getting the factory methods\nin top shape.\n\n\u003c!-- cargo-rdme end --\u003e\n\n","project_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fgeeknoid%2Fdst-factory","html_url":"https://awesome.ecosyste.ms/projects/github.com%2Fgeeknoid%2Fdst-factory","lists_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fgeeknoid%2Fdst-factory/lists"}