commit b5ef4bce68fbd00c740fbfe2451388f1a73bd900 · zbrox.com/jacquard

+179 -393

crates/jacquard-common/src/types/value.rs

···

       99
        
       

     

       100
        
               for (key, value) in json {

     

       101
        
                   if key == "$type" {

     

       102
       -
                       continue; // skip, because we've already handled it

     

       103
        
                   }

     

       104
        
                   match string_key_type_guess(key) {

     

       105
       -
                       DataModelType::Null => {

     

       106
       -
                           if value.is_null() {

     

       107
       -
                               map.insert(key.to_smolstr(), Data::Null);

     

       108
       -
                           } else {

     

       109
       -
                               map.insert(key.to_smolstr(), Data::from_json(value));

     

       110
       -
                           }

     

       111
        
                       }

     

       112
       -
                       DataModelType::Boolean => {

     

       113
       -
                           if let Some(value) = value.as_bool() {

     

       114
       -
                               map.insert(key.to_smolstr(), Data::Boolean(value));

     

       115
       -
                           } else {

     

       116
       -
                               map.insert(key.to_smolstr(), Data::from_json(value));

     

       117
       -
                           }

     

       118
        
                       }

     

       119
       -
                       DataModelType::Integer => {

     

       120
       -
                           if let Some(int) = value.as_i64() {

     

       121
       -
                               map.insert(key.to_smolstr(), Data::Integer(int));

     

       122
       -
                           } else {

     

       123
       -
                               map.insert(key.to_smolstr(), Data::from_json(value));

     

       124
       -
                           }

     

       125
        
                       }

     

       126
       -
                       DataModelType::Bytes => {

     

       127
       -
                           if let Some(value) = value.as_str() {

     

       128
       -
                               map.insert(key.to_smolstr(), decode_bytes(value));

     

       129
       -
                           } else {

     

       130
       -
                               map.insert(key.to_smolstr(), Data::from_json(value));

     

       131
       -
                           }

     

       132
        
                       }

     

       133
        
                       DataModelType::CidLink => {

     

       134
        
                           if let Some(value) = value.as_object() {

     
···

       141
        
                               map.insert(key.to_smolstr(), Data::from_json(value));

     

       142
        
                           }

     

       143
        
                       }

     

       144
       -
                       DataModelType::Blob => {

     

       145
       -
                           if let Some(value) = value.as_object() {

     

       146
       -
                               map.insert(key.to_smolstr(), Object::from_json(value));

     

       147
       -
                           } else {

     

       148
       -
                               map.insert(key.to_smolstr(), Data::from_json(value));

     

       149
       -
                           }

     

       150
        
                       }

     

       151
       -
                       DataModelType::Array => {

     

       152
       -
                           if let Some(value) = value.as_array() {

     

       153
       -
                               map.insert(key.to_smolstr(), Data::Array(Array::from_json(value)));

     

       154
       -
                           } else {

     

       155
       -
                               map.insert(key.to_smolstr(), Data::from_json(value));

     

       156
       -
                           }

     

       157
        
                       }

     

       158
       -
                       DataModelType::Object => {

     

       159
       -
                           if let Some(value) = value.as_object() {

     

       160
       -
                               map.insert(key.to_smolstr(), Object::from_json(value));

     

       161
       -
                           } else {

     

       162
       -
                               map.insert(key.to_smolstr(), Data::from_json(value));

     

       163
       -
                           }

     

       164
        
                       }

     

       165
       -
                       DataModelType::String(string_type) => {

     

       166
       -
                           if let Some(value) = value.as_str() {

     

       167
       -
                               match string_type {

     

       168
       -
                                   LexiconStringType::Datetime => {

     

       169
       -
                                       if let Ok(datetime) = Datetime::from_str(value) {

     

       170
       -
                                           map.insert(

     

       171
       -
                                               key.to_smolstr(),

     

       172
       -
                                               Data::String(AtprotoStr::Datetime(datetime)),

     

       173
       -
                                           );

     

       174
       -
                                       } else {

     

       175
       -
                                           map.insert(

     

       176
       -
                                               key.to_smolstr(),

     

       177
       -
                                               Data::String(AtprotoStr::String(value.into())),

     

       178
       -
                                           );

     

       179
       -
                                       }

     

       180
       -
                                   }

     

       181
       -
                                   LexiconStringType::AtUri => {

     

       182
       -
                                       if let Ok(value) = AtUri::new(value) {

     

       183
       -
                                           map.insert(

     

       184
       -
                                               key.to_smolstr(),

     

       185
       -
                                               Data::String(AtprotoStr::AtUri(value)),

     

       186
       -
                                           );

     

       187
       -
                                       } else {

     

       188
       -
                                           map.insert(

     

       189
       -
                                               key.to_smolstr(),

     

       190
       -
                                               Data::String(AtprotoStr::String(value.into())),

     

       191
       -
                                           );

     

       192
       -
                                       }

     

       193
       -
                                   }

     

       194
       -
                                   LexiconStringType::Did => {

     

       195
       -
                                       if let Ok(value) = Did::new(value) {

     

       196
       -
                                           map.insert(

     

       197
       -
                                               key.to_smolstr(),

     

       198
       -
                                               Data::String(AtprotoStr::Did(value)),

     

       199
       -
                                           );

     

       200
       -
                                       } else {

     

       201
       -
                                           map.insert(

     

       202
       -
                                               key.to_smolstr(),

     

       203
       -
                                               Data::String(AtprotoStr::String(value.into())),

     

       204
       -
                                           );

     

       205
       -
                                       }

     

       206
       -
                                   }

     

       207
       -
                                   LexiconStringType::Handle => {

     

       208
       -
                                       if let Ok(value) = Handle::new(value) {

     

       209
       -
                                           map.insert(

     

       210
       -
                                               key.to_smolstr(),

     

       211
       -
                                               Data::String(AtprotoStr::Handle(value)),

     

       212
       -
                                           );

     

       213
       -
                                       } else {

     

       214
       -
                                           map.insert(

     

       215
       -
                                               key.to_smolstr(),

     

       216
       -
                                               Data::String(AtprotoStr::String(value.into())),

     

       217
       -
                                           );

     

       218
       -
                                       }

     

       219
       -
                                   }

     

       220
       -
                                   LexiconStringType::AtIdentifier => {

     

       221
       -
                                       if let Ok(value) = AtIdentifier::new(value) {

     

       222
       -
                                           map.insert(

     

       223
       -
                                               key.to_smolstr(),

     

       224
       -
                                               Data::String(AtprotoStr::AtIdentifier(value)),

     

       225
       -
                                           );

     

       226
       -
                                       } else {

     

       227
       -
                                           map.insert(

     

       228
       -
                                               key.to_smolstr(),

     

       229
       -
                                               Data::String(AtprotoStr::String(value.into())),

     

       230
       -
                                           );

     

       231
       -
                                       }

     

       232
       -
                                   }

     

       233
       -
                                   LexiconStringType::Nsid => {

     

       234
       -
                                       if let Ok(value) = Nsid::new(value) {

     

       235
       -
                                           map.insert(

     

       236
       -
                                               key.to_smolstr(),

     

       237
       -
                                               Data::String(AtprotoStr::Nsid(value)),

     

       238
       -
                                           );

     

       239
       -
                                       } else {

     

       240
       -
                                           map.insert(

     

       241
       -
                                               key.to_smolstr(),

     

       242
       -
                                               Data::String(AtprotoStr::String(value.into())),

     

       243
       -
                                           );

     

       244
       -
                                       }

     

       245
       -
                                   }

     

       246
       -
                                   LexiconStringType::Cid => {

     

       247
       -
                                       if let Ok(value) = Cid::new(value.as_bytes()) {

     

       248
       -
                                           map.insert(

     

       249
       -
                                               key.to_smolstr(),

     

       250
       -
                                               Data::String(AtprotoStr::Cid(value)),

     

       251
       -
                                           );

     

       252
       -
                                       } else {

     

       253
       -
                                           map.insert(

     

       254
       -
                                               key.to_smolstr(),

     

       255
       -
                                               Data::String(AtprotoStr::String(value.into())),

     

       256
       -
                                           );

     

       257
       -
                                       }

     

       258
       -
                                   }

     

       259
       -
                                   LexiconStringType::Language => {

     

       260
       -
                                       if let Ok(value) = Language::new(value) {

     

       261
       -
                                           map.insert(

     

       262
       -
                                               key.to_smolstr(),

     

       263
       -
                                               Data::String(AtprotoStr::Language(value)),

     

       264
       -
                                           );

     

       265
       -
                                       } else {

     

       266
       -
                                           map.insert(

     

       267
       -
                                               key.to_smolstr(),

     

       268
       -
                                               Data::String(AtprotoStr::String(value.into())),

     

       269
       -
                                           );

     

       270
       -
                                       }

     

       271
       -
                                   }

     

       272
       -
                                   LexiconStringType::Tid => {

     

       273
       -
                                       if let Ok(value) = Tid::new(value) {

     

       274
       -
                                           map.insert(

     

       275
       -
                                               key.to_smolstr(),

     

       276
       -
                                               Data::String(AtprotoStr::Tid(value)),

     

       277
       -
                                           );

     

       278
       -
                                       } else {

     

       279
       -
                                           map.insert(

     

       280
       -
                                               key.to_smolstr(),

     

       281
       -
                                               Data::String(AtprotoStr::String(value.into())),

     

       282
       -
                                           );

     

       283
       -
                                       }

     

       284
       -
                                   }

     

       285
       -
                                   LexiconStringType::RecordKey => {

     

       286
       -
                                       if let Ok(value) = Rkey::new(value) {

     

       287
       -
                                           map.insert(

     

       288
       -
                                               key.to_smolstr(),

     

       289
       -
                                               Data::String(AtprotoStr::RecordKey(RecordKey::from(value))),

     

       290
       -
                                           );

     

       291
       -
                                       } else {

     

       292
       -
                                           map.insert(

     

       293
       -
                                               key.to_smolstr(),

     

       294
       -
                                               Data::String(AtprotoStr::String(value.into())),

     

       295
       -
                                           );

     

       296
       -
                                       }

     

       297
       -
                                   }

     

       298
       -
                                   LexiconStringType::Uri(_) => {

     

       299
       -
                                       if let Ok(uri) = Uri::new(value) {

     

       300
       -
                                           map.insert(

     

       301
       -
                                               key.to_smolstr(),

     

       302
       -
                                               Data::String(AtprotoStr::Uri(uri)),

     

       303
       -
                                           );

     

       304
       -
                                       } else {

     

       305
       -
                                           map.insert(

     

       306
       -
                                               key.to_smolstr(),

     

       307
       -
                                               Data::String(AtprotoStr::String(value.into())),

     

       308
       -
                                           );

     

       309
       -
                                       }

     

       310
       -
                                   }

     

       311
       -
                                   LexiconStringType::String => {

     

       312
       -
                                       map.insert(key.to_smolstr(), Data::String(parse_string(value)));

     

       313
       -
                                   }

     

       314
       -
                               }

     

       315
       -
                           } else {

     

       316
       -
                               map.insert(key.to_smolstr(), Data::from_json(value));

     

       317
       -
                           }

     

       318
        
                       }

     

       319
        
                   }

     

       320
        
               }

     
···

       334
        
       

     

       335
        
               for (key, value) in cbor {

     

       336
        
                   if key == "$type" {

     

       337
       -
                       continue; // skip, because we've already handled it

     

       338
        
                   }

     

       339
       -
                   match string_key_type_guess(key) {

     

       340
       -
                       DataModelType::Null => {

     

       341
       -
                           if *value == Ipld::Null {

     

       342
       -
                               map.insert(key.to_smolstr(), Data::Null);

     

       343
       -
                           } else {

     

       344
       -
                               map.insert(key.to_smolstr(), Data::from_cbor(value));

     

       345
       -
                           }

     

       346
        
                       }

     

       347
       -
                       DataModelType::Boolean => {

     

       348
       -
                           if let Ipld::Bool(value) = value {

     

       349
       -
                               map.insert(key.to_smolstr(), Data::Boolean(*value));

     

       350
       -
                           } else {

     

       351
       -
                               map.insert(key.to_smolstr(), Data::from_cbor(value));

     

       352
       -
                           }

     

       353
        
                       }

     

       354
       -
                       DataModelType::Integer => {

     

       355
       -
                           if let Ipld::Integer(int) = value {

     

       356
       -
                               map.insert(key.to_smolstr(), Data::Integer(*int as i64));

     

       357
       -
                           } else {

     

       358
       -
                               map.insert(key.to_smolstr(), Data::from_cbor(value));

     

       359
       -
                           }

     

       360
        
                       }

     

       361
       -
                       DataModelType::Bytes => {

     

       362
       -
                           if let Ipld::Bytes(value) = value {

     

       363
       -
                               map.insert(key.to_smolstr(), Data::Bytes(Bytes::copy_from_slice(value)));

     

       364
       -
                           } else {

     

       365
       -
                               map.insert(key.to_smolstr(), Data::from_cbor(value));

     

       366
       -
                           }

     

       367
        
                       }

     

       368
       -
                       DataModelType::Blob => {

     

       369
       -
                           if let Ipld::Map(value) = value {

     

       370
       -
                               map.insert(key.to_smolstr(), Object::from_cbor(value));

     

       371
       -
                           } else {

     

       372
       -
                               map.insert(key.to_smolstr(), Data::from_cbor(value));

     

       373
       -
                           }

     

       374
        
                       }

     

       375
       -
                       DataModelType::Array => {

     

       376
       -
                           if let Ipld::List(value) = value {

     

       377
       -
                               map.insert(key.to_smolstr(), Data::Array(Array::from_cbor(value)));

     

       378
       -
                           } else {

     

       379
       -
                               map.insert(key.to_smolstr(), Data::from_cbor(value));

     

       380
       -
                           }

     

       381
        
                       }

     

       382
       -
                       DataModelType::Object => {

     

       383
       -
                           if let Ipld::Map(value) = value {

     

       384
       -
                               map.insert(key.to_smolstr(), Object::from_cbor(value));

     

       385
       -
                           } else {

     

       386
       -
                               map.insert(key.to_smolstr(), Data::from_cbor(value));

     

       387
       -
                           }

     

       388
        
                       }

     

       389
       -
                       DataModelType::String(string_type) => {

     

       390
       -
                           if let Ipld::String(value) = value {

     

       391
       -
                               match string_type {

     

       392
       -
                                   LexiconStringType::Datetime => {

     

       393
       -
                                       if let Ok(datetime) = Datetime::from_str(value) {

     

       394
       -
                                           map.insert(

     

       395
       -
                                               key.to_smolstr(),

     

       396
       -
                                               Data::String(AtprotoStr::Datetime(datetime)),

     

       397
       -
                                           );

     

       398
       -
                                       } else {

     

       399
       -
                                           map.insert(

     

       400
       -
                                               key.to_smolstr(),

     

       401
       -
                                               Data::String(AtprotoStr::String(value.into())),

     

       402
       -
                                           );

     

       403
       -
                                       }

     

       404
       -
                                   }

     

       405
       -
                                   LexiconStringType::AtUri => {

     

       406
       -
                                       if let Ok(value) = AtUri::new(value) {

     

       407
       -
                                           map.insert(

     

       408
       -
                                               key.to_smolstr(),

     

       409
       -
                                               Data::String(AtprotoStr::AtUri(value)),

     

       410
       -
                                           );

     

       411
       -
                                       } else {

     

       412
       -
                                           map.insert(

     

       413
       -
                                               key.to_smolstr(),

     

       414
       -
                                               Data::String(AtprotoStr::String(value.into())),

     

       415
       -
                                           );

     

       416
       -
                                       }

     

       417
       -
                                   }

     

       418
       -
                                   LexiconStringType::Did => {

     

       419
       -
                                       if let Ok(value) = Did::new(value) {

     

       420
       -
                                           map.insert(

     

       421
       -
                                               key.to_smolstr(),

     

       422
       -
                                               Data::String(AtprotoStr::Did(value)),

     

       423
       -
                                           );

     

       424
       -
                                       } else {

     

       425
       -
                                           map.insert(

     

       426
       -
                                               key.to_smolstr(),

     

       427
       -
                                               Data::String(AtprotoStr::String(value.into())),

     

       428
       -
                                           );

     

       429
       -
                                       }

     

       430
       -
                                   }

     

       431
       -
                                   LexiconStringType::Handle => {

     

       432
       -
                                       if let Ok(value) = Handle::new(value) {

     

       433
       -
                                           map.insert(

     

       434
       -
                                               key.to_smolstr(),

     

       435
       -
                                               Data::String(AtprotoStr::Handle(value)),

     

       436
       -
                                           );

     

       437
       -
                                       } else {

     

       438
       -
                                           map.insert(

     

       439
       -
                                               key.to_smolstr(),

     

       440
       -
                                               Data::String(AtprotoStr::String(value.into())),

     

       441
       -
                                           );

     

       442
       -
                                       }

     

       443
       -
                                   }

     

       444
       -
                                   LexiconStringType::AtIdentifier => {

     

       445
       -
                                       if let Ok(value) = AtIdentifier::new(value) {

     

       446
       -
                                           map.insert(

     

       447
       -
                                               key.to_smolstr(),

     

       448
       -
                                               Data::String(AtprotoStr::AtIdentifier(value)),

     

       449
       -
                                           );

     

       450
       -
                                       } else {

     

       451
       -
                                           map.insert(

     

       452
       -
                                               key.to_smolstr(),

     

       453
       -
                                               Data::String(AtprotoStr::String(value.into())),

     

       454
       -
                                           );

     

       455
       -
                                       }

     

       456
       -
                                   }

     

       457
       -
                                   LexiconStringType::Nsid => {

     

       458
       -
                                       if let Ok(value) = Nsid::new(value) {

     

       459
       -
                                           map.insert(

     

       460
       -
                                               key.to_smolstr(),

     

       461
       -
                                               Data::String(AtprotoStr::Nsid(value)),

     

       462
       -
                                           );

     

       463
       -
                                       } else {

     

       464
       -
                                           map.insert(

     

       465
       -
                                               key.to_smolstr(),

     

       466
       -
                                               Data::String(AtprotoStr::String(value.into())),

     

       467
       -
                                           );

     

       468
       -
                                       }

     

       469
       -
                                   }

     

       470
       -
                                   LexiconStringType::Cid => {

     

       471
       -
                                       if let Ok(value) = Cid::new(value.as_bytes()) {

     

       472
       -
                                           map.insert(

     

       473
       -
                                               key.to_smolstr(),

     

       474
       -
                                               Data::String(AtprotoStr::Cid(value)),

     

       475
       -
                                           );

     

       476
       -
                                       } else {

     

       477
       -
                                           map.insert(

     

       478
       -
                                               key.to_smolstr(),

     

       479
       -
                                               Data::String(AtprotoStr::String(value.into())),

     

       480
       -
                                           );

     

       481
       -
                                       }

     

       482
       -
                                   }

     

       483
       -
                                   LexiconStringType::Language => {

     

       484
       -
                                       if let Ok(value) = Language::new(value) {

     

       485
       -
                                           map.insert(

     

       486
       -
                                               key.to_smolstr(),

     

       487
       -
                                               Data::String(AtprotoStr::Language(value)),

     

       488
       -
                                           );

     

       489
       -
                                       } else {

     

       490
       -
                                           map.insert(

     

       491
       -
                                               key.to_smolstr(),

     

       492
       -
                                               Data::String(AtprotoStr::String(value.into())),

     

       493
       -
                                           );

     

       494
       -
                                       }

     

       495
       -
                                   }

     

       496
       -
                                   LexiconStringType::Tid => {

     

       497
       -
                                       if let Ok(value) = Tid::new(value) {

     

       498
       -
                                           map.insert(

     

       499
       -
                                               key.to_smolstr(),

     

       500
       -
                                               Data::String(AtprotoStr::Tid(value)),

     

       501
       -
                                           );

     

       502
       -
                                       } else {

     

       503
       -
                                           map.insert(

     

       504
       -
                                               key.to_smolstr(),

     

       505
       -
                                               Data::String(AtprotoStr::String(value.into())),

     

       506
       -
                                           );

     

       507
       -
                                       }

     

       508
       -
                                   }

     

       509
       -
                                   LexiconStringType::RecordKey => {

     

       510
       -
                                       if let Ok(value) = Rkey::new(value) {

     

       511
       -
                                           map.insert(

     

       512
       -
                                               key.to_smolstr(),

     

       513
       -
                                               Data::String(AtprotoStr::RecordKey(RecordKey::from(value))),

     

       514
       -
                                           );

     

       515
       -
                                       } else {

     

       516
       -
                                           map.insert(

     

       517
       -
                                               key.to_smolstr(),

     

       518
       -
                                               Data::String(AtprotoStr::String(value.into())),

     

       519
       -
                                           );

     

       520
       -
                                       }

     

       521
       -
                                   }

     

       522
       -
                                   LexiconStringType::Uri(_) => {

     

       523
       -
                                       if let Ok(uri) = Uri::new(value) {

     

       524
       -
                                           map.insert(

     

       525
       -
                                               key.to_smolstr(),

     

       526
       -
                                               Data::String(AtprotoStr::Uri(uri)),

     

       527
       -
                                           );

     

       528
       -
                                       } else {

     

       529
       -
                                           map.insert(

     

       530
       -
                                               key.to_smolstr(),

     

       531
       -
                                               Data::String(AtprotoStr::String(value.into())),

     

       532
       -
                                           );

     

       533
       -
                                       }

     

       534
       -
                                   }

     

       535
       -
                                   LexiconStringType::String => {

     

       536
       -
                                       map.insert(key.to_smolstr(), Data::String(parse_string(value)));

     

       537
       -
                                   }

     

       538
       -
                               }

     

       539
       -
                           } else {

     

       540
       -
                               map.insert(key.to_smolstr(), Data::from_cbor(value));

     

       541
       -
                           }

     

       542
        
                       }

     

       543
        
                       _ => {

     

       544
        
                           map.insert(key.to_smolstr(), Data::from_cbor(value));

     
···

       547
        
               }

     

       548
        
       

     

       549
        
               Data::Object(Object(map))

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       550
        
           }

     

       551
        
       }

     

       552

···

       99
        
       

     

       100
        
               for (key, value) in json {

     

       101
        
                   if key == "$type" {

     

       102
       +
                       map.insert(key.to_smolstr(), Data::from_json(value));

     

       103
        
                   }

     

       104
        
                   match string_key_type_guess(key) {

     

       105
       +
                       DataModelType::Null if value.is_null() => {

     

       106
       +
                           map.insert(key.to_smolstr(), Data::Null);

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       107
        
                       }

     

       108
       +
                       DataModelType::Boolean if value.is_boolean() => {

     

       109
       +
                           map.insert(key.to_smolstr(), Data::Boolean(value.as_bool().unwrap()));

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       110
        
                       }

     

       111
       +
                       DataModelType::Integer if value.is_i64() => {

     

       112
       +
                           map.insert(key.to_smolstr(), Data::Integer(value.as_i64().unwrap()));

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       113
        
                       }

     

       114
       +
                       DataModelType::Bytes if value.is_string() => {

     

       115
       +
                           map.insert(key.to_smolstr(), decode_bytes(value.as_str().unwrap()));

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       116
        
                       }

     

       117
        
                       DataModelType::CidLink => {

     

       118
        
                           if let Some(value) = value.as_object() {

     
···

       125
        
                               map.insert(key.to_smolstr(), Data::from_json(value));

     

       126
        
                           }

     

       127
        
                       }

     

       128
       +
                       DataModelType::Blob if value.is_object() => {

     

       129
       +
                           map.insert(

     

       130
       +
                               key.to_smolstr(),

     

       131
       +
                               Object::from_json(value.as_object().unwrap()),

     

       132
       +
                           );

     

       0
        
       
     

       133
        
                       }

     

       134
       +
                       DataModelType::Array if value.is_array() => {

     

       135
       +
                           map.insert(

     

       136
       +
                               key.to_smolstr(),

     

       137
       +
                               Data::Array(Array::from_json(value.as_array().unwrap())),

     

       138
       +
                           );

     

       0
        
       
     

       139
        
                       }

     

       140
       +
                       DataModelType::Object if value.is_object() => {

     

       141
       +
                           map.insert(

     

       142
       +
                               key.to_smolstr(),

     

       143
       +
                               Object::from_json(value.as_object().unwrap()),

     

       144
       +
                           );

     

       0
        
       
     

       145
        
                       }

     

       146
       +
                       DataModelType::String(string_type) if value.is_string() => {

     

       147
       +
                           insert_string(&mut map, key, value.as_str().unwrap(), string_type);

     

       148
       +
                       }

     

       149
       +
                       _ => {

     

       150
       +
                           map.insert(key.to_smolstr(), Data::from_json(value));

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       151
        
                       }

     

       152
        
                   }

     

       153
        
               }

     
···

       167
        
       

     

       168
        
               for (key, value) in cbor {

     

       169
        
                   if key == "$type" {

     

       170
       +
                       map.insert(key.to_smolstr(), Data::from_cbor(value));

     

       171
        
                   }

     

       172
       +
                   match (string_key_type_guess(key), value) {

     

       173
       +
                       (DataModelType::Null, Ipld::Null) => {

     

       174
       +
                           map.insert(key.to_smolstr(), Data::Null);

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       175
        
                       }

     

       176
       +
                       (DataModelType::Boolean, Ipld::Bool(value)) => {

     

       177
       +
                           map.insert(key.to_smolstr(), Data::Boolean(*value));

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       178
        
                       }

     

       179
       +
                       (DataModelType::Integer, Ipld::Integer(int)) => {

     

       180
       +
                           map.insert(key.to_smolstr(), Data::Integer(*int as i64));

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       181
        
                       }

     

       182
       +
                       (DataModelType::Bytes, Ipld::Bytes(value)) => {

     

       183
       +
                           map.insert(key.to_smolstr(), Data::Bytes(Bytes::copy_from_slice(value)));

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       184
        
                       }

     

       185
       +
                       (DataModelType::Blob, Ipld::Map(value)) => {

     

       186
       +
                           map.insert(key.to_smolstr(), Object::from_cbor(value));

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       187
        
                       }

     

       188
       +
                       (DataModelType::Array, Ipld::List(value)) => {

     

       189
       +
                           map.insert(key.to_smolstr(), Data::Array(Array::from_cbor(value)));

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       190
        
                       }

     

       191
       +
                       (DataModelType::Object, Ipld::Map(value)) => {

     

       192
       +
                           map.insert(key.to_smolstr(), Object::from_cbor(value));

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       193
        
                       }

     

       194
       +
                       (DataModelType::String(string_type), Ipld::String(value)) => {

     

       195
       +
                           insert_string(&mut map, key, value, string_type);

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       196
        
                       }

     

       197
        
                       _ => {

     

       198
        
                           map.insert(key.to_smolstr(), Data::from_cbor(value));

     
···

       201
        
               }

     

       202
        
       

     

       203
        
               Data::Object(Object(map))

     

       204
       +
           }

     

       205
       +
       }

     

       206
       +
       

     

       207
       +
       pub fn insert_string<'s>(

     

       208
       +
           map: &mut BTreeMap<SmolStr, Data<'s>>,

     

       209
       +
           key: &'s str,

     

       210
       +
           value: &'s str,

     

       211
       +
           string_type: LexiconStringType,

     

       212
       +
       ) {

     

       213
       +
           match string_type {

     

       214
       +
               LexiconStringType::Datetime => {

     

       215
       +
                   if let Ok(datetime) = Datetime::from_str(value) {

     

       216
       +
                       map.insert(

     

       217
       +
                           key.to_smolstr(),

     

       218
       +
                           Data::String(AtprotoStr::Datetime(datetime)),

     

       219
       +
                       );

     

       220
       +
                   } else {

     

       221
       +
                       map.insert(

     

       222
       +
                           key.to_smolstr(),

     

       223
       +
                           Data::String(AtprotoStr::String(value.into())),

     

       224
       +
                       );

     

       225
       +
                   }

     

       226
       +
               }

     

       227
       +
               LexiconStringType::AtUri => {

     

       228
       +
                   if let Ok(value) = AtUri::new(value) {

     

       229
       +
                       map.insert(key.to_smolstr(), Data::String(AtprotoStr::AtUri(value)));

     

       230
       +
                   } else {

     

       231
       +
                       map.insert(

     

       232
       +
                           key.to_smolstr(),

     

       233
       +
                           Data::String(AtprotoStr::String(value.into())),

     

       234
       +
                       );

     

       235
       +
                   }

     

       236
       +
               }

     

       237
       +
               LexiconStringType::Did => {

     

       238
       +
                   if let Ok(value) = Did::new(value) {

     

       239
       +
                       map.insert(key.to_smolstr(), Data::String(AtprotoStr::Did(value)));

     

       240
       +
                   } else {

     

       241
       +
                       map.insert(

     

       242
       +
                           key.to_smolstr(),

     

       243
       +
                           Data::String(AtprotoStr::String(value.into())),

     

       244
       +
                       );

     

       245
       +
                   }

     

       246
       +
               }

     

       247
       +
               LexiconStringType::Handle => {

     

       248
       +
                   if let Ok(value) = Handle::new(value) {

     

       249
       +
                       map.insert(key.to_smolstr(), Data::String(AtprotoStr::Handle(value)));

     

       250
       +
                   } else {

     

       251
       +
                       map.insert(

     

       252
       +
                           key.to_smolstr(),

     

       253
       +
                           Data::String(AtprotoStr::String(value.into())),

     

       254
       +
                       );

     

       255
       +
                   }

     

       256
       +
               }

     

       257
       +
               LexiconStringType::AtIdentifier => {

     

       258
       +
                   if let Ok(value) = AtIdentifier::new(value) {

     

       259
       +
                       map.insert(

     

       260
       +
                           key.to_smolstr(),

     

       261
       +
                           Data::String(AtprotoStr::AtIdentifier(value)),

     

       262
       +
                       );

     

       263
       +
                   } else {

     

       264
       +
                       map.insert(

     

       265
       +
                           key.to_smolstr(),

     

       266
       +
                           Data::String(AtprotoStr::String(value.into())),

     

       267
       +
                       );

     

       268
       +
                   }

     

       269
       +
               }

     

       270
       +
               LexiconStringType::Nsid => {

     

       271
       +
                   if let Ok(value) = Nsid::new(value) {

     

       272
       +
                       map.insert(key.to_smolstr(), Data::String(AtprotoStr::Nsid(value)));

     

       273
       +
                   } else {

     

       274
       +
                       map.insert(

     

       275
       +
                           key.to_smolstr(),

     

       276
       +
                           Data::String(AtprotoStr::String(value.into())),

     

       277
       +
                       );

     

       278
       +
                   }

     

       279
       +
               }

     

       280
       +
               LexiconStringType::Cid => {

     

       281
       +
                   if let Ok(value) = Cid::new(value.as_bytes()) {

     

       282
       +
                       map.insert(key.to_smolstr(), Data::String(AtprotoStr::Cid(value)));

     

       283
       +
                   } else {

     

       284
       +
                       map.insert(

     

       285
       +
                           key.to_smolstr(),

     

       286
       +
                           Data::String(AtprotoStr::String(value.into())),

     

       287
       +
                       );

     

       288
       +
                   }

     

       289
       +
               }

     

       290
       +
               LexiconStringType::Language => {

     

       291
       +
                   if let Ok(value) = Language::new(value) {

     

       292
       +
                       map.insert(key.to_smolstr(), Data::String(AtprotoStr::Language(value)));

     

       293
       +
                   } else {

     

       294
       +
                       map.insert(

     

       295
       +
                           key.to_smolstr(),

     

       296
       +
                           Data::String(AtprotoStr::String(value.into())),

     

       297
       +
                       );

     

       298
       +
                   }

     

       299
       +
               }

     

       300
       +
               LexiconStringType::Tid => {

     

       301
       +
                   if let Ok(value) = Tid::new(value) {

     

       302
       +
                       map.insert(key.to_smolstr(), Data::String(AtprotoStr::Tid(value)));

     

       303
       +
                   } else {

     

       304
       +
                       map.insert(

     

       305
       +
                           key.to_smolstr(),

     

       306
       +
                           Data::String(AtprotoStr::String(value.into())),

     

       307
       +
                       );

     

       308
       +
                   }

     

       309
       +
               }

     

       310
       +
               LexiconStringType::RecordKey => {

     

       311
       +
                   if let Ok(value) = Rkey::new(value) {

     

       312
       +
                       map.insert(

     

       313
       +
                           key.to_smolstr(),

     

       314
       +
                           Data::String(AtprotoStr::RecordKey(RecordKey::from(value))),

     

       315
       +
                       );

     

       316
       +
                   } else {

     

       317
       +
                       map.insert(

     

       318
       +
                           key.to_smolstr(),

     

       319
       +
                           Data::String(AtprotoStr::String(value.into())),

     

       320
       +
                       );

     

       321
       +
                   }

     

       322
       +
               }

     

       323
       +
               LexiconStringType::Uri(_) => {

     

       324
       +
                   if let Ok(uri) = Uri::new(value) {

     

       325
       +
                       map.insert(key.to_smolstr(), Data::String(AtprotoStr::Uri(uri)));

     

       326
       +
                   } else {

     

       327
       +
                       map.insert(

     

       328
       +
                           key.to_smolstr(),

     

       329
       +
                           Data::String(AtprotoStr::String(value.into())),

     

       330
       +
                       );

     

       331
       +
                   }

     

       332
       +
               }

     

       333
       +
               LexiconStringType::String => {

     

       334
       +
                   map.insert(key.to_smolstr(), Data::String(parse_string(value)));

     

       335
       +
               }

     

       336
        
           }

     

       337
        
       }

     

       338