Timerix/DTLib
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

deserialization completed?

Browse Source
This commit is contained in:
Timerix22 2022-03-02 22:25:16 +03:00
parent 4778d0ca2a
commit 83f4a1775e
19 changed files with 191 additions and 298 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

7
.vscode/settings.json vendored
View File

@ -8,7 +8,12 @@
"ranges": "c",
"streambuf": "c",
"chrono": "c",
"string": "c"
"string": "c",
"deque": "c",
"list": "c",
"unordered_map": "c",
"vector": "c",
"system_error": "c"
},
"C_Cpp.errorSquiggles": "Disabled"
}

2
DTLib/Experimental/Tester.cs
View File

@ -12,6 +12,6 @@ public static class Tester
operation();
clock.Stop();
double time=(double)(clock.ElapsedTicks)/Stopwatch.Frequency/repeats;
LogNoTime("y",$"operation ","b",op_name,"y"," took ","b",time.ToString(),"y"," seconds");
LogNoTime("y",$"operation ","b",op_name,"y"," lasted ","b",time.ToString(),"y"," seconds");
}
}

10
DtsodC/src/Autoarr/Autoarr2.c
View File

@ -11,3 +11,13 @@ define_Autoarr2(int64)
define_Autoarr2(float)
define_Autoarr2(double)
define_Autoarr2(Unitype)
//right func to clear array of unitype values
void Autoarr2_Unitype_clear(Autoarr2(Unitype)* ar){
for(uint32 blockI=0;blockI<ar->blocks_count-1;blockI++)
for(uint32 elemI=0;elemI<ar->max_block_length;elemI++)
Unitype_free(ar->values[blockI][elemI]);
for(uint32 elemI=0;elemI<ar->block_length;elemI++)
Unitype_free(ar->values[ar->blocks_count-1][elemI]);
Autoarr2_clear(ar);
}

3
DtsodC/src/Autoarr/Autoarr2.h
View File

@ -15,4 +15,5 @@ declare_Autoarr2(float)
declare_Autoarr2(double)
declare_Autoarr2(Unitype)
//right func to clear array of unitype values
void Autoarr2_Unitype_clear(Autoarr2(Unitype)* ar);

2
DtsodC/src/Autoarr/Autoarr2_define.h
View File

@ -37,7 +37,7 @@ void __Autoarr2_set_##type(Autoarr2_##type* ar, uint32 index, type element){\
\
void __Autoarr2_clear_##type(Autoarr2_##type* ar){\
for(uint16 i=0; i<ar->blocks_count;i++)\
free(ar->values[i]); \
free(ar->values[i]); \
free(ar->values);\
ar->values=NULL;\
ar->blocks_count=0;\

51
DtsodC/src/DtsodParser/DtsodV24.c
View File

@ -31,18 +31,27 @@ Hashtable* __deserialize(char** _text, bool calledRecursively){
string ReadName(){
string nameStr={text,0};
while ((c=*++text)) switch (c){
while ((c=*text++)) switch (c){
case ' ': case '\t':
case '\r': case '\n':
if(nameStr.length!=0)
throw_wrongchar(c);
nameStr.ptr++;
break;
case '#':
SkipComment();
if(nameStr.length!=0)
throw_wrongchar(c);
nameStr.ptr=text;
break;
case '}':
if(!calledRecursively) throw_wrongchar(c);
case ':':
return nameStr;
case '$':
if(nameStr.length!=0)
throw_wrongchar(c);
nameStr.ptr++;
partOfDollarList=true;
break;
case '=': case ';':
@ -68,7 +77,6 @@ Hashtable* __deserialize(char** _text, bool calledRecursively){
bool prevIsBackslash = false;
string str={text,1};
while ((c=*++text)!='"' || prevIsBackslash){
printf("%c",c);
if (!c) throw(ERR_ENDOFSTR);
prevIsBackslash= c=='\\' && !prevIsBackslash;
str.length++;
@ -121,24 +129,33 @@ Hashtable* __deserialize(char** _text, bool calledRecursively){
if(str.ptr[str.length-1]=='"'){
//removing quotes
string _str={str.ptr+1,str.length-1};
return UniPtr(CharPtr, string_cpToCharPtr(_str));
return UniPtr(CharPtr,string_cpToCharPtr(_str));
}
else throw_wrongchar(*str.ptr);
break;
default:
switch(str.ptr[str.length-1]){
case 'f':
return Uni(Double,strtod(string_cpToCharPtr(str),NULL));
case 'u': ; //some weird "empty statement"
//not "statement"
uint64 lu=0;
sscanf(string_cpToCharPtr(str),"%lu",&lu);
return Uni(UInt64,lu);
case 'f': {
char* _c=string_cpToCharPtr(str);
Unitype rez=Uni(Double,strtod(_c,NULL));
free(_c);
return rez;
}
case 'u': {
uint64 lu=0;
char* _c=string_cpToCharPtr(str);
sscanf(_c,"%lu",&lu);
free(_c);
return Uni(UInt64,lu);
}
case '0': case '1': case '2': case '3': case '4':
case '5': case '6': case '7': case '8': case '9': ;
int64 li=0;
sscanf(string_cpToCharPtr(str),"%li",&li);
return Uni(Int64,li);
case '5': case '6': case '7': case '8': case '9': {
int64 li=0;
char* _c=string_cpToCharPtr(str);
sscanf(_c,"%li",&li);
free(_c);
return Uni(Int64,li);
}
default:
throw_wrongchar(str.ptr[str.length-1]);
}
@ -187,7 +204,8 @@ Hashtable* __deserialize(char** _text, bool calledRecursively){
return UniNull;
};
while((c=*text++)){
text--;
while((c=*++text)){
string name=ReadName();
if(name.length==0) //end of file or '}' in recursive call
goto END;
@ -196,8 +214,9 @@ Hashtable* __deserialize(char** _text, bool calledRecursively){
if(partOfDollarList){
Autoarr2(Unitype)* list;
Unitype lu;
if(Hashtable_try_get(dict,nameCPtr, &lu))
if(Hashtable_try_get(dict,nameCPtr, &lu)){
list=(Autoarr2(Unitype)*)lu.VoidPtr;
}
else{
list=malloc(sizeof(Autoarr2(Unitype)));
*list=Autoarr2_create(Unitype,ARR_BC,ARR_BL);

187
DtsodC/src/DtsodParser/DtsodV24.c.backup
View File

@ -1,187 +0,0 @@
#include "DtsodV24.h"
#include "../Autoarr/StringBuilder.h"
#define ARR_BC 2
#define ARR_BL 8
Hashtable* __parse(string textStr, bool called_recursively){
Hashtable* dict=Hashtable_create();
char* text=textStr.ptr;
char c;
bool partOfDollarList=false;
bool readingList=false;
void throw_wrongchar(char _c){
char errstr[]="unexpected <c>";
errstr[12]=_c;
throw(errstr);
};
void SkipComment(){
while((c=*++text)!='\n')
if(!c) throw(ERR_ENDOFSTR);
};
string ReadName(){
string nameStr={text,0};
while ((c=*++text)) switch (c){
case ' ': case '\t':
case '\r': case '\n':
break;
case '#':
SkipComment();
break;
case '}':
if(!called_recursively) throw_wrongchar(c);
case ':':
return nameStr;
case '$':
partOfDollarList=true;
break;
case '=': case ';':
case '\'': case '"':
case '[': case ']':
case '{':
throw_wrongchar(c);
default:
nameStr.length++;
break;
}
if(nameStr.length>0) throw(ERR_ENDOFSTR);
return nameStr;
};
Unitype ReadValue(){
string valueStr={text,0};
//returns part of <text> with brackets
string ReadString(){
bool prevIsBackslash = false;
string str={text,1};
while ((c=*++text)!='"' || prevIsBackslash){
if (!c) throw(ERR_ENDOFSTR);
prevIsBackslash= c=='\\' && !prevIsBackslash;
str.length++;
}
str.length++;
return str;
};
Autoarr2(Unitype)* ReadList(){
Autoarr2(Unitype)* list=malloc(sizeof(Autoarr2(Unitype)));
*list=Autoarr2_create(Unitype,ARR_BC,ARR_BL);
readingList=true;
while (true){
Autoarr2_add(list,ReadValue());
if (!readingList) break;
}
return list;
};
Hashtable* ReadDtsod(){
short bracketBalance = 1;
string dtsodStr={text+1,0};
while ((c=*++text))//пропускает начальный символ '{'
{
if(bracketBalance) switch (c)
{
case ' ': case '\t':
case '\r': case '\n':
break;
case '#':
SkipComment();
break;
case '{':
bracketBalance++;
dtsodStr.length++;
break;
case '}':
bracketBalance--;
if (bracketBalance != 0)
dtsodStr.length++;
break;
case '"':
string _str=ReadString();
dtsodStr.length+=_str.length;
break;
default:
dtsodStr.length++;
break;
}
else return __parse(dtsodStr,true);
}
throw(ERR_ENDOFSTR);
return NULL;
};
Unitype ParseValue(string str){
throw(ERR_NOTIMPLEMENTED);
return UniNull;
};
while ((c=*++text)) switch (c){
case ' ': case '\t':
case '\r': case '\n':
break;
case '#':
SkipComment();
break;
case '"':
valueStr=ReadString();
break;
case '\'':
text++;
char valueChar=*++text;
if (*++text != '\'') throw("after <'> should be char");
else if (valueStr.length!=0) throw("char assignement error");
else return Uni(Char,valueChar);
break;
case ';':
case ',':
return ParseValue(valueStr);
case '[':
return UniPtr(AutoarrUnitypePtr,ReadList());
case ']':
readingList=false;
break;
case '{':
return UniPtr(HashtablePtr,ReadDtsod());
case '=': case ':':
case '}': case '$':
throw_wrongchar(c);
default:
valueStr.length++;
break;
}
throw(ERR_ENDOFSTR);
return UniNull;
};
while((c=*text++)){
string name=ReadName();
if(name.length==0) //closing figure bracket in recursive call or end of file
return dict;
char* nameCPtr=string_cpToCharPtr(name);
Unitype value=ReadValue();
if(partOfDollarList){
Autoarr2(Unitype)* list;
Unitype lu;
if(Hashtable_try_get(dict,nameCPtr, &lu))
list=(Autoarr2(Unitype)*)lu.VoidPtr;
else{
list=malloc(sizeof(Autoarr2(Unitype)));
*list=Autoarr2_create(Unitype,ARR_BC,ARR_BL);
Hashtable_add(dict,nameCPtr,UniPtr(AutoarrUnitypePtr,list));
}
Autoarr2_add(list,value);
}
else Hashtable_add(dict,nameCPtr,value);
}
return dict;
}
Hashtable* DtsodV24_parse(const char* text) { return __parse((text,false); }

15
DtsodC/src/Hashtable/Hashtable.c
View File

@ -1,7 +1,5 @@
#include "Hashtable.h"
define_Autoarr2(KeyValuePair)
// amount of rows
#define HT_HEIN_MIN 0
#define HT_HEIN_MAX 5
@ -21,10 +19,7 @@ Hashtable* Hashtable_create(){
void Hashtable_free(Hashtable* ht){
for(uint16 i=0;i<HT_HEIGHTS[ht->hein];i++){
Autoarr2(KeyValuePair)* ar=(Autoarr2(KeyValuePair)*)(ht->rows+i);
for(uint32 i=0;i<Autoarr2_length(ar);i++)
free(Autoarr2_getptr(ar,i)->key);
Autoarr2_clear(ar);
Autoarr2_KeyValuePair_clear(ht->rows+i);
}
free(ht->rows);
free(ht);
@ -66,7 +61,7 @@ void Hashtable_add_pair(Hashtable* ht, KeyValuePair p){
Autoarr2_add(getrow(ht,p.key,true),p);
}
void Hashtable_add(Hashtable* ht, char* key, Unitype u){
Hashtable_add_pair(ht,cpair(key,u));
Hashtable_add_pair(ht,KVPair(key,u));
}
//returns null or pointer to value in hashtable
@ -90,12 +85,12 @@ Unitype Hashtable_get(Hashtable* ht, char* key){
return UniNull;
}
KeyValuePair Hashtable_get_pair(Hashtable* ht, char* key){
return cpair(key,Hashtable_get(ht,key));
return KVPair(key,Hashtable_get(ht,key));
}
bool Hashtable_try_get(Hashtable* ht, char* key, Unitype* output){
Unitype u=Hashtable_get(ht,key);
*output=u;
return u.type==Null;
return u.type!=Null;
}
/* void Hashtable_set_pair(Hashtable* ht, KeyValuePair p){
@ -103,4 +98,4 @@ bool Hashtable_try_get(Hashtable* ht, char* key, Unitype* output){
}
}
void Hashtable_set(Hashtable* ht, char* key, Unitype u){ Hashtable_set_pair(ht,cpair(key,u)); } */
void Hashtable_set(Hashtable* ht, char* key, Unitype u){ Hashtable_set_pair(ht,KVPair(key,u)); } */

14
DtsodC/src/Hashtable/Hashtable.h
View File

@ -1,18 +1,8 @@
#pragma once
#include "../base/base.h"
#include "../Autoarr/Autoarr2.h"
#include "hash.h"
typedef struct KeyValuePair{
char* key;
Unitype value;
} KeyValuePair;
//copies string and value to new KeyValuePair
KeyValuePair cpair(char* key, Unitype value);
declare_Autoarr2(KeyValuePair)
#include "KeyValuePair.h"
typedef struct Hashtable{
uint8 hein; //height=HT_HEIGHTS[hein]
@ -27,7 +17,7 @@ uint32 Hashtable_height(Hashtable* ht);
//adds charptr and value to new KeyValuePair
//use charbuf_copy() to create new string if needed
#define cpair(key,value) (KeyValuePair){key,value}
#define KVPair(key,value) (KeyValuePair){key,value}
void Hashtable_add_pair(Hashtable* ht, KeyValuePair p);

20
DtsodC/src/Hashtable/KeyValuePair.c Normal file
View File

@ -0,0 +1,20 @@
#include "KeyValuePair.h"
define_Autoarr2(KeyValuePair)
//proper way to clear a KVP
void KeyValuePair_free(KeyValuePair p){
free(p.key);
Unitype_free(p.value);
}
//func for KVP array clearing
void Autoarr2_KeyValuePair_clear(Autoarr2_KeyValuePair* ar){
for(uint16 blockI=0; blockI < ar->blocks_count-1; blockI++)
for(uint16 elemI=0; elemI < ar->max_block_length; elemI++)
KeyValuePair_free(ar->values[blockI][elemI]);
for(uint16 elemI=0; elemI < ar->block_length; elemI++)
KeyValuePair_free(ar->values[ar->blocks_count-1][elemI]);
Autoarr2_clear(ar);
}

15
DtsodC/src/Hashtable/KeyValuePair.h Normal file
View File

@ -0,0 +1,15 @@
#include "../base/base.h"
#include "../Autoarr/Autoarr2.h"
typedef struct KeyValuePair{
char* key;
Unitype value;
} KeyValuePair;
declare_Autoarr2(KeyValuePair)
//proper way to clear a KVP
void KeyValuePair_free(KeyValuePair p);
//func to clear KVP array
void Autoarr2_KeyValuePair_clear(Autoarr2_KeyValuePair* ar);

18
DtsodC/src/SearchTree/SearchTree.c
View File

@ -31,23 +31,7 @@ void STNode_free(STNode* node){
free(node->branches);
}
if(node->value.VoidPtr)
switch (node->value.type) {
case Int8Ptr: case UInt8Ptr:
case Int16Ptr: case UInt16Ptr:
case Int32Ptr: case UInt32Ptr:
case Int64Ptr: case UInt64Ptr:
free(node->value.VoidPtr);
break;
/*case AutoarrPtr:
Autoarr_clear((Autoarr*)node->value.VoidPtr);
free(node->value.VoidPtr);
break;*/
case STNodePtr:
STNode_free((STNode*)node->value.VoidPtr);
break;
default: // value is not ptr
break;
}
Unitype_free(node->value);
free(node);
}

2
DtsodC/src/base/base.h
View File

@ -15,5 +15,5 @@ void fsleep(float sec);
(codeblock);\
clock_t stop=clock();\
double t=(double)(stop-start)/CLOCKS_PER_SEC/repeats;\
printf("\e[93moperation \e[94m%s\e[93m took \e[94m%lf \e[93mseconds\n",opname,t);\
printf("\e[93moperation \e[94m%s\e[93m lasted \e[94m%lf \e[93mseconds\n",opname,t);\
})

14
DtsodC/src/base/twmp.h
View File

@ -1,14 +0,0 @@
case CharPtr: return "CharPtr";
case UniversalType: return "UniversalType";
case STNodePtr: return "STNodePtr";
case HashtablePtr: return "HashtablePtr";
case AutoarrInt8Ptr: return "AutoarrInt8Ptr";
case AutoarrUInt8Ptr: return "AutoarrUInt8Ptr";
case AutoarrInt16Ptr: return "AutoarrInt16Ptr";
case AutoarrUInt16Ptr: return "AutoarrUInt16Ptr";
case AutoarrInt32Ptr: return "AutoarrInt32Ptr";
case AutoarrUInt32Ptr: return "AutoarrUInt32Ptr";
case AutoarrInt64Ptr: return "AutoarrInt64Ptr";
case AutoarrUInt64Ptr: return "AutoarrUInt64Ptr";
case AutoarrUnitypePtr: return "AutoarrUnitypePtr";
case AutoarrKVPairPtr: return "AutoarrKVPairPtr";

97
DtsodC/src/base/types.c
View File

@ -1,5 +1,8 @@
#include "types.h"
#include "errors.h"
#include "../Autoarr/Autoarr2.h"
#include "../Hashtable/Hashtable.h"
#include "../SearchTree/SearchTree.h"
const char* typename(my_type t){
switch (t) {
@ -24,39 +27,41 @@ const char* typename(my_type t){
case UInt32Ptr: return "UInt32Ptr";
case Int64Ptr: return "Int64Ptr";
case UInt64Ptr: return "UInt64Ptr";
case UniversalType: return "Unitype";
case CharPtr: return "CharPtr";
case STNodePtr: return "STNodePtr";
case HashtablePtr: return "HashtablePtr";
case AutoarrInt8Ptr: return "AutoarrInt8Ptr";
case AutoarrUInt8Ptr: return "AutoarrUInt8Ptr";
case AutoarrInt16Ptr: return "AutoarrInt16Ptr";
case AutoarrUInt16Ptr: return "AutoarrUInt16Ptr";
case AutoarrInt32Ptr: return "AutoarrInt32Ptr";
case AutoarrUInt32Ptr: return "AutoarrUInt32Ptr";
case AutoarrInt64Ptr: return "AutoarrInt64Ptr";
case AutoarrUInt64Ptr: return "AutoarrUInt64Ptr";
case AutoarrUnitypePtr: return "AutoarrUnitypePtr";
case AutoarrKVPairPtr: return "AutoarrKVPairPtr";
case STNodePtr: return "STNodePtr";
case HashtablePtr: return "HashtablePtr";
case UniversalType: return "Unitype";
case AutoarrInt8Ptr: return "AutoarrInt8Ptr";
case AutoarrUInt8Ptr: return "AutoarrUInt8Ptr";
case AutoarrInt16Ptr: return "AutoarrInt16Ptr";
case AutoarrUInt16Ptr: return "AutoarrUInt16Ptr";
case AutoarrInt32Ptr: return "AutoarrInt32Ptr";
case AutoarrUInt32Ptr: return "AutoarrUInt32Ptr";
case AutoarrInt64Ptr: return "AutoarrInt64Ptr";
case AutoarrUInt64Ptr: return "AutoarrUInt64Ptr";
case AutoarrUnitypePtr: return "AutoarrUnitypePtr";
case AutoarrKVPairPtr: return "AutoarrKVPairPtr";
default: throw(ERR_WRONGTYPE); return "ERROR";
}
}
int8 typesize(my_type type){
switch (type){
case Null: return 0;
case Double: return sizeof(double);
case Float: return sizeof(float);
case Bool: return sizeof(bool);
//frees VoidPtr value or does nothing if type isn't pointer
void Unitype_free(Unitype u){
switch (u.type) {
case Null:
case Float:
case Double:
case Char:
case Bool:
case Int8:
case UInt8: return 1;
case UInt8:
case Int16:
case UInt16: return 2;
case UInt16:
case Int32:
case UInt32: return 4;
case UInt32:
case Int64:
case UInt64: return 8;
case UInt64:
break;
case Int8Ptr:
case UInt8Ptr:
case Int16Ptr:
@ -64,8 +69,48 @@ int8 typesize(my_type type){
case Int32Ptr:
case UInt32Ptr:
case Int64Ptr:
case UInt64Ptr: return sizeof(void*);
case UniversalType: return "Unitype";
default: throw(ERR_WRONGTYPE); return -1;
case UInt64Ptr:
case CharPtr:
free(u.VoidPtr);
break;
case HashtablePtr:
Hashtable_free(u.VoidPtr);
break;
case STNodePtr:
STNode_free(u.VoidPtr);
break;
case AutoarrInt8Ptr:
Autoarr2_clear(((Autoarr2(int8)*)u.VoidPtr));
break;
case AutoarrUInt8Ptr:
Autoarr2_clear(((Autoarr2(uint8)*)u.VoidPtr));
break;
case AutoarrInt16Ptr:
Autoarr2_clear(((Autoarr2(int16)*)u.VoidPtr));
break;
case AutoarrUInt16Ptr:
Autoarr2_clear(((Autoarr2(uint16)*)u.VoidPtr));
break;
case AutoarrInt32Ptr:
Autoarr2_clear(((Autoarr2(int32)*)u.VoidPtr));
break;
case AutoarrUInt32Ptr:
Autoarr2_clear(((Autoarr2(uint32)*)u.VoidPtr));
break;
case AutoarrInt64Ptr:
Autoarr2_clear(((Autoarr2(int64)*)u.VoidPtr));
break;
case AutoarrUInt64Ptr:
Autoarr2_clear(((Autoarr2(uint64)*)u.VoidPtr));
break;
case AutoarrUnitypePtr:
Autoarr2_Unitype_clear(u.VoidPtr);
free((Autoarr2(Unitype)*)u.VoidPtr);
break;
case AutoarrKVPairPtr:
Autoarr2_KeyValuePair_clear(u.VoidPtr);
free((Autoarr2(KeyValuePair)*)u.VoidPtr);
break;
default: throw(ERR_WRONGTYPE);
}
}

6
DtsodC/src/base/types.h
View File

@ -14,7 +14,8 @@ typedef enum my_type{
Null, Float, Double, Char, Bool,
UInt8, Int8, UInt16, Int16, UInt32, Int32, UInt64, Int64,
UInt8Ptr, Int8Ptr, UInt16Ptr, Int16Ptr, UInt32Ptr, Int32Ptr, UInt64Ptr, Int64Ptr,
CharPtr, UniversalType, STNodePtr, HashtablePtr,
CharPtr, STNodePtr, HashtablePtr,
UniversalType,
AutoarrInt8Ptr, AutoarrUInt8Ptr, AutoarrInt16Ptr, AutoarrUInt16Ptr,
AutoarrInt32Ptr, AutoarrUInt32Ptr, AutoarrInt64Ptr, AutoarrUInt64Ptr,
AutoarrUnitypePtr, AutoarrKVPairPtr
@ -45,3 +46,6 @@ static const Unitype UniFalse={Bool,.Bool=false};
#define Uni(TYPE,VAL) (Unitype){.type=TYPE,.TYPE=VAL}
#define UniPtr(TYPE,VAL) (Unitype){.type=TYPE,.VoidPtr=VAL}
//frees VoidPtr value or does nothing if type isn't pointer
void Unitype_free(Unitype u);

17
DtsodC/tests/test_dtsod.c
View File

@ -2,10 +2,10 @@
#include "../src/DtsodParser/DtsodV24.h"
void test_dtsod(){
printf("\e[96m-------------[test_dtsod]-------------\n");
optime(__func__,1,({
printf("\e[96m-------------[test_dtsod]-------------\n");
char text[]=
"message:\n"
const char text[]=
"$message:\n"
"{\n"
" type: \"sent\";\n"
" time: \"15.12.2021 20:51:24 +03:00\";\n"
@ -14,10 +14,15 @@ void test_dtsod(){
" message_id: 920734809096077353ul;\n"
" text: \"_$\\\"\\\\'''\n\ta ыыы000;2;=:%d;```\";\n"
"};\n";
Hashtable* dtsod=DtsodV24_deserialize(text);
Unitype id;
Hashtable* dtsod;
optime("deserialize",1,(dtsod=DtsodV24_deserialize(text)));
printf("\e[92mhashtable_get(message)->\n\e[94m");
Unitype msg=Hashtable_get(dtsod,"message");
printuni(msg);
Unitype id=Hashtable_get(msg.VoidPtr,"message_id");
printf("\e[92mid: %lu",id.UInt64);
Autoarr2(Unitype)* ar=msg.VoidPtr;
id=Hashtable_get(Autoarr2_get(ar,0).VoidPtr,"message_id");
printf("\e[92m\nmessage_id: %lu\n",id.UInt64);
Hashtable_free(dtsod);
}));
}

1
TestProgram/DtsodC/DictTest.cs
View File

@ -1,4 +1,3 @@
using static DTLib.Experimental.Tester;
using static TestProgram.Program;
namespace TestProgram;

2
TestProgram/Program.cs
View File

@ -8,11 +8,13 @@ global using System.Threading.Tasks;
global using DTLib;
global using DTLib.Extensions;
global using DTLib.Experimental;
global using static DTLib.Experimental.Tester;
global using DTLib.Filesystem;
global using DTLib.Dtsod;
using DTLib.Loggers;
using TestProgram.DtsodV2X;
namespace TestProgram;
static class Program