под "сериализовывать" я имею в виду serde-стайл штуки разумеется)

в принципе можно всё индексировать на этапе сериализации и подменять поля соответствующие на эти индексы

но мб есть какое-то стандартное решение?

Писать кастомный Serializer

ну я скорее про общий принцип

а не про детали реализации

в принципе можно всё индексировать на этапе сериализации и подменять поля соответствующие на эти индексы

Ты хочешь граф зависимостей сериализовать?

вообще нет, но думаю задача эквивалентная я парсю плюсовый код, и, например, в классах поля ссылаются на другие типы, которые тоже парсятся

кстати, а как правильно говорить — парсю или паршу?)

в принципе, каждый тип однозначно определяется полным именем (включая неймспейсы), так что можно на этом остановиться и записывать эту штуку в качестве идентификатора

но может есть какой-то более труЪ-вей

Мне кажется серде тут не совсем подходит, у тебя AST

Типы тут скорее некий глобальный хэшмап

Если я правильно понял что ты хочешь

ну короче, вот есть у меня распарсенные типы, которые всячески друг на друга ссылаются, грубо говоря struct Type { kind: TypeKind, ... } enum TypeKind { ... Alias { origin: Rc<Type> }, ... }

и я хочу это дело сериализовать

сиречь, записать в какой-нибудь джейсончик или типа того, не суть важно

чтобы эти данные потом можно было использовать из других мест

разумеется я могу (и делаю) хэш-мапу, где все типы хранятся, у которой ключ — полное имя типа

и я могу сделать кастомную сериализацию для всех полей, где встречается Rc<Type>, чтобы записывалось просто полное имя типа

но, например, загрузка этих данных обратно будет крайне болезненной, потому что придётся пилить кастомный десериализатор, что, как известно, суть боль

и я подумал: может есть какое-то стандартное решение, чтобы мне ничего не пришлось ручками писать :)

разумеется я могу (и делаю) хэш-мапу, где все типы хранятся, у которой ключ — полное имя типа

Так у тебя только имена типов хранятся или полный набор полей?

мапа — это "имя" -> "полное описание типа"

Не встречал готовых решений, несколько раз писал десерилзаторы для простых типов, вроде никакой боли не встречал)

Не встречал готовых решений, несколько раз писал десерилзаторы для простых типов, вроде никакой боли не встречал)

Для serde?

Да

Там в самих тикетах автор частотдает крутые снипеты

Не встречал готовых решений, несколько раз писал десерилзаторы для простых типов, вроде никакой боли не встречал)

это ты крут

я ни разу не писал десериализатор для серде, но смотрел на них и плакал :(

я вижу у себя такую потенциальную проблему при десериализации: вот я десериализую тип, и там встречается поле, которое ссылается на тип, который ещё не десериализован

и что мне делать? =)

это ты крут

На самом деле нет, это как с бороу чекером, надо понять суть

я вижу у себя такую потенциальную проблему при десериализации: вот я десериализую тип, и там встречается поле, которое ссылается на тип, который ещё не десериализован

Десериализовать сначала типы в память Потом поля

Потом печать

я вижу у себя такую потенциальную проблему при десериализации: вот я десериализую тип, и там встречается поле, которое ссылается на тип, который ещё не десериализован

Так у тебя там не тип а описание его, когда ты делаешь десерилищациб ты указываешь в какой тип положить, в типе соответственно аннотации

Десериализовать сначала типы в память Потом поля

ну то есть серилизовать в промежуточный тип, а-ля HashMap<Name, Option<Rc<Type>>>, а потом разворачивать его в HashMap<Name, Rc<Type>>

let data: Types = from()

CStr и CString нужны только для интеропа с С

Не совсем. Не помню точно как, но Path только в CString может. Возможно путаю с ещё одной строкой (я вообще про нативную системную).

У тебя все пытается применится к Types

Который по сути будет типа рекурсивный

Абстргируйся ща

переписал добрую часть сетевого протокола MotionSource for Cemuhook на Rust. теперь пытаюсь понять, зачем я это сделал, и какой фронтэнд к нему прикрутить.

Допустим у тебя структура struct X {name, field: X}

Rc<>

Так вот десерилищатор спускается сверху, и раскладывает все по полям

Добавляя вложенные элементы

в смысле добавляя?

я не могу создать тип с пустым полем =)

Ну например у тебя fields: Vec<X>

Он будет заполнять вектор элементами

переписал добрую часть сетевого протокола MotionSource for Cemuhook на Rust. теперь пытаюсь понять, зачем я это сделал, и какой фронтэнд к нему прикрутить.

суть: использовать любое устройство для эмуляции гироскопа (каноничная реализация: DualShock 4). Через такой драйвер всякие мобилки и кофеварки можно использовать с эмулятором WiiU (Cemu) чтобы, например, перетягивать игровые предметы движениями в воздухе.

я не могу создать тип с пустым полем =)

Еще раз десерелизатор не создает новый тип, он распаковывает в тот который ты ему задаш

Еще раз десерелизатор не создает новый тип, он распаковывает в тот который ты ему задаш

короче как парсер строки

ээ

минутку

теперь либо действительно компилить под мобилки, проксируя показания нативного гироскопа, либо так поиграться на ноуте с мышкой

вот примерно как всё это дело дефайнится

ну короче, вот есть у меня распарсенные типы, которые всячески друг на друга ссылаются, грубо говоря struct Type { kind: TypeKind, ... } enum TypeKind { ... Alias { origin: Rc<Type> }, ... }

и лежит это всё в HashMap<Name, Rc<Type>>

для интереса

книга дракона

Абстрактно, let type: HashMap<String, Rc<Type>> = deserialize_from(data)

так

при этом внутри Type тоже есть Rc<Type>>

Десеризатор заполняет хешмап

То есть на верхнем уровне создает хешмап, потом начинает создавать элементы для него

так

теперь либо действительно компилить под мобилки, проксируя показания нативного гироскопа, либо так поиграться на ноуте с мышкой

призываю тапок @tapok_satan пояснить за последние веяния моды в области фронтендов на расте. ну или хотя бы биндингов каких...

Десерелизирует ключ, поскольку значение комбинировано он создает Type и начинает заполняеть его поля

Десерелизирует ключ, поскольку значение комбинировано он создает Type и начинает заполняеть его поля

что значит "создаёт Type"?

его можно создать, только когда все поля известны

Условно)

Если не условно

Он получает все поля type

И ищет в исходном потоке соответствие ключей

Учитывая serde rename

Он получает все поля type

ну и вот тут и возникает проблема

ну и вот тут и возникает проблема

Не возникает, он получает вначале только названия полей

ещё как возникает

потому что одно из полей type'а в сериализованном виде — это просто имя типа