Zobrazit příspěvky

Tato sekce Vám umožňuje zobrazit všechny příspěvky tohoto uživatele. Prosím uvědomte si, že můžete vidět příspěvky pouze z oblastí Vám přístupných.


Příspěvky - Marekuss

Stran: [1] 2 3
1
/dev/null / Re:Pravnické důsledky cenzury na českém webu
« kdy: 15. 03. 2022, 09:05:01 »
Mal som pocit ze root je forum/stranka zamerana na technicke problemy - ale vsimam si ze posledne dva-tri roky sa to tu profiluje na format diskuzii z idnes/facebooku a podobne.

...Ved tam tiez udajne sirili dezinformacie, ktore sa neskor ukazali ako pravdive. Takisto isli proti prudu. ...
Mozete dolozit link? Prosim link na dezinformaciu  a link na zdroj ktory potvrdil ze dezinformacia bola pravdiva

Neskor sa ukazalo, aspon v CR, ze opatrenia boli nezakonne a zrusene.
Mozete mi tak isto dodat zdroj?

Prisiel konflikt a zrazu prask, mame genialny dovod zrusit weby a zacat s "demokratickou" cenzurou.
Demokraticka cenzura neexistuje. Demokracia je vlada vacsiny... Cenzura je ucelne obmedzovanie informacii

Ja by som bol rad, keby sa z root-u stala technicky zamerana stranka....



2
Vývoj / Re:Rust - std::ANY alebo lepší návrh?
« kdy: 11. 01. 2022, 22:08:44 »
Ahojte Kolegovia, ozivujem temu, nakolko pribudli skusenosti ohladom Rustu, tak davam na zretel lepsi navrh :)
za pozornost stoji "create_table" v "impl Database" (1)
pripadne "pub fn push<T: CreateTable + ToDatabase>(&mut self, data: &T) " v (2)

Samozrejme je mozne nahradit Vec -> HashSet - to je kazdeho volba :)
Kód: [Vybrat]
/* temp */
/* use MYSQL::Connection; */
pub struct Connection {}
impl Connection {
    pub fn execute(/* ... */){/* ... */}
}

pub enum DatabaseMembers {
    X,
    Y,
    Z
}

// Various Structs
pub struct X {
    pub name: String
}

pub struct Y {
    pub text: String
}

pub struct Z {
    pub value: u64
}

/* Traits */

pub trait CreateTable {
    fn create_table(c: &Connection) -> Result<(), Error>;
    fn table_type() -> DatabaseMembers;
}

pub trait FromDatabase : Sized {
    fn get(c: &Connection) -> Result<Self, Error>;
}

pub trait ToDatabase {
    fn push(c: &Connection, data: &Self) -> Result<(), Error>;
}

/* Trait implementation */

/* Impl for X */
impl CreateTable for X {
    fn table_type() -> DatabaseMembers{
        DatabaseMembers::X;
    }

    fn create_table(c: &Connection) -> Result<(), Error>{
        let query =
        "CREATE TABLE IF NOT EXISTS X (
            id      INTEGER PRIMARY KEY,
            text    TEXT NOT NULL,
        );";

        Ok(())
    }
}

impl ToDatabase for X {
    fn push(c: &Connection, data: &Self) -> Result<(), PError> {
        let query =
        "INSERT INTO ...
        (name, ...)
        VALUES
        (?1, ...)
        ";
    }
}

impl FromDatabase for X {
    fn get(c: &Connection, id: usize) -> Result<Self, Error>{
        let query =
        "SELECT *
        FROM ...
        WHERE ... id=?1
        ";
        /* ... */
        Ok(X{ /*... */})
    }
}
/* Impl for Y */
impl CreateTable for Y {
    fn table_type() -> DatabaseMembers{
        DatabaseMembers::Y;
    }

    fn create_table(c: &Connection) -> Result<(), Error>{
        let query =
        "CREATE TABLE IF NOT EXISTS Y (
            id      INTEGER PRIMARY KEY,
            text    TEXT NOT NULL,
        );";

        Ok(())
    }
}

impl ToDatabase for Y {
    fn push(c: &Connection, data: &Self) -> Result<(), PError> {
        let query =
        "INSERT INTO ...
        (name, ...)
        VALUES
        (?1, ...)
        ";
    }
}

impl FromDatabase for Y {
    fn get(c: &Connection, id: usize) -> Result<Self, Error>{
        let query =
        "SELECT *
        FROM ...
        WHERE ... id=?1
        ";
        /* ... */
        Ok(Y{ /*... */})
    }
}

/* Impl for Z */
/* ... */

pub struct Database {
    c: Connection,
    initialized_tables: Vec<DatabaseTables>,
}

impl Database {
    pub fn open_temporary() -> Database {
        let mut db = Database {
            c: Connection::open_in_memory(),
        }
        /* ... */
        Ok(db)
    }

    /* (1) - Explicitne vytvorim tabulku ...*/
    pub fn create_table<T: CreateTable>(&mut self) -> Result<(), PError> {
        if !self.initialized_tables.contains(&T::table_type()) {
            let dbtable = T::create_table(&self.conn)?;
            self.initialized_tables.push(dbtable);
        }   

        Ok(())
    }

    pub fn push<T: CreateTable + ToDatabase>(&mut self, data: &T) {
        /* (2) - alebo implicitne vytvorim tabulku */
        if !self.initialized_tables.contains(&T::table_type()) {
            T::create_table(&self.conn)?;
            self.initialized_tables.push(&T::table_type());
        }
        ToDatabase::push(&self.conn, data)
    }

    pub fn get<T: FromDatabase>(&self, id: usize) -> Result<T, PError>{
        FromDatabase::get(&self.conn, uid)
    }

}

fn main() {

    let mut db: Database = Database::open_temporary();

    /* (1) - explicitne vytvorim tabulku pre X */
    db.create_table::<X>();
    let x = X {name: String::from("Ahoj")};
    db.push(&x);

    // (2) - implicitne vytvorim tabulku pre Y */
    let y = Y {text: String::from("Ahoj")};
    db.push(&y);
}

Pekny vecer

3
Vývoj / Re:Rust - serde/bincode serializacia/deserializacia dat
« kdy: 21. 12. 2021, 19:49:16 »
OP: Došel jsi prosímtě k něčemu? Zafungoval Ti ten "untagged"?

Zdar, ano, untagged je nakoniec uzitocne makro :)
Nakolko Rust len skumam, tak som sa nepustal do zbytocnych zlozitosti... vsak sa bude refaktorovat.

Je to +- ok, ked bude cas, tak dvojity matach() blok nahradim makrom, tak isto by slo nahradit aj "pub fn value(&self) -> MessageBodyType" ako makro.. mozno casom

Kód: [Vybrat]
use serde_repr::*;
use serde::{Deserialize, Serialize};

#[derive(Serialize_repr, Deserialize_repr, PartialEq, Debug)]
#[serde(untagged)]
#[repr(u8)]
pub enum MessageBodyType {
    Version = 11,
    BatteryHealth = 22,
}

#[derive(Serialize, Deserialize, PartialEq, Debug)]
pub enum MessageBody {
    Version(Version),
    BatteryHealth(BatteryHealth),
}

impl MessageBody {
    pub fn value(&self) -> MessageBodyType {
        match *self {
            MessageBody::Version(_) => MessageBodyType::Version,
            MessageBody::BatteryHealth(_) => MessageBodyType::BatteryHealth
        }
    }
}

#[derive(Serialize, Deserialize, PartialEq, Debug)]
#[repr(C)]
pub struct MessageHeader {
    message_type: MessageBodyType,  // 1
    _pad0: u8,                      // 1
    body_size: u16,                 // 2
    crc: u32,                       // 4
}

#[derive(Serialize, Deserialize, PartialEq, Debug)]
struct Message {
    header: MessageHeader,
    body: MessageBody,
}

impl Message {
    pub fn serialize_body(mb: MessageBody) -> Result<Vec<u8>, Error> {

        let mut body_vec: Vec<u8>;
        match &mb {
            MessageBody::Version(v) => {
                body_vec = bincode::serialize(&v)?;
            },
            MessageBody::BatteryHealth(h) => {
                body_vec = bincode::serialize(&h)?;
            }
        }

        let header : MessageHeader = MessageHeader {
            message_type: mb.value(),
            _pad0: HEADER_PAD,
            body_size: body_vec.len() as u32,
            crc: 0,
        };

        let mut header_vec = bincode::serialize(&header)?;
        header_vec.append(&mut body_vec);

        Ok(header_vec)
    }

    pub fn deserialize_body<'a>(bytes: &'a [u8]) -> Result<MessageBody, Error> {
        if bytes.len() < std::mem::size_of::<MessageHeader>(){
            return Err(());
        }

        let message_header_len = std::mem::size_of::<MessageHeader>();

        match header.message_type {
            MessageBodyType::Version => {
                let version: Version = bincode::deserialize(&bytes[message_header_len..bytes.len()])?;
                return Ok(MessageBody::Version(version));
            },   
            MessageBodyType::BatteryHealth => {
                let battery: BatteryHealth = bincode::deserialize(&bytes[message_header_len..bytes.len()])?;
                return Ok(MessageBody::BatteryHealth(battery));
            }
        }
    }
}

#[derive(Serialize, Deserialize, PartialEq, Debug)]
#[repr(C)]
pub struct Version {
    pub x1: u8,       // 1
    pub x2: u8,       // 1
    pub x3: u16,      // 2
}

#[derive(Serialize, Deserialize, PartialEq, Debug)]
#[repr(C)]
pub struct BatteryHealth {
    pub x1: u8,       // 1
    pub x2: u8,       // 1
    pub x3: u16,      // 2
}

fn main () -> Result<(), Box<(dyn std::error::Error + 'static)>> {
    let serialized_version: Vec<u8> = Message::serialize(MessageBody::Version(Version{x1: 3, x2: 6, x3: 0xFAFA})).unwrap();
    let serialized_battery: Vec<u8> = Message::serialize(MessageBody::BatteryHealth(BatteryHealth{x1: 10, x2: 20, x3: 0x0A0A})).unwrap();

    let deserialized_version: MessageBody = Message::deserialize(&serialized_version).unwrap();


  Ok(())
}

4
Vývoj / Re:Rust - serde/bincode serializacia/deserializacia dat
« kdy: 19. 12. 2021, 19:48:25 »
Spravy su vsehovsudy jednoduche, nieje nutne ich balit do msgpack, protobuf, bson a pod.

ASN.1 BER ?
[/provokace]

(Hihihi :-D a zdrhám až se mi za patami práší, než po mně někdo něco hodí.)

Prave naopak, ja sa rad niecomu novemu priucim, nieje dovod vyskakovat z okna :)


Sice netusim, ako moc je Rust hranaty, moderny alebo firkulinsky - to musia zhodnotit lepsi ako ja.
Ma nejaky prinos implementacia ASN.1 BER/TLV a obdobne na strane Rust-u a zaroven v C, ked si budem vymienat spravy o maximalnej dlzke 64bytov? Neviem pytam sa...

5
Vývoj / Re:Rust - serde/bincode serializacia/deserializacia dat
« kdy: 18. 12. 2021, 14:25:40 »
Ukaž, jak bys to udělal v C a že v Rustu to nejde. Rust má i normální "hloupý" union (untagged). OP použil tagged union a vadí mu, že vysokoúrovňový serializační mechanismus ho zachová v pořádku se vším všudy. Ale jinak jasně, pokud Ti to za to nestojí, nezabývej se tím.

OP to nevadi, OP poukazal na fakt ze to tak je. OP by rad vyuzil plne jazyk Rust (kludne aj nizkourovnovu serializaciu (ak mas predstavu ako)) a zaroven sa vyhol unsafe {}.

Vies mi poradit ako serializovat struktury (kludne aj bez serde/bincode), s tym ze vyuzijem plne jazyk Rust "se vsim vsudy", vyhnem sa "unsafe" semantike?

Rad by som sa vyhol flamewar C vs Rust, vsetci tusime ako to zapiseme v C, ako to spravit Safe v Ruste?

6
Hardware / Re:Tiskárna kompatibílní s Linuxem
« kdy: 17. 12. 2021, 22:41:26 »
Mam Xerox 3025 Laserovka (tlaciaren + scanner) - rebrandovany Samsung, s instalaciou driverov nebol problem (Ubuntu 20.04).
Tlacenie v pohode a scan funguje tiez (saned).

V tejto cenovej kategorii som sa rozhodoval aj medzi Brotherom, ten ma tlacovu hlavu na 5000stran, a potom vymena, Xerox ju ma v kazete.
Ale po tych nervoch (nastavit ako network printer), asi by som si ju druhy krat nekupil, ak ju budes mat cez USB ku kompu, tak vsetko OK.

7
Vývoj / Rust - serde/bincode serializacia/deserializacia dat
« kdy: 17. 12. 2021, 22:34:04 »
Ahojte kolegovia,

Tentokrat sa na Vas obraciam kvoli serializacii/deserializacii struktur(y) - jednoduchych MSG (TCP/IP) medzi serverom(Rust) a klientom C/freeRTOS(32bit MCU, 128kb RAM).
Spravy su vsehovsudy jednoduche, nieje nutne ich balit do msgpack, protobuf, bson a pod.

Na serializaciu/deserializaciu som pouzil serde/bincode, s tym ze vysledna sprava sa sklada z MessageHeader + MessageBody => Message. Na tomto designe sa mi nepacia dve veci, a to:

MessageHeader::message_type je ulozena hodnota z MessageBodyType::{Version, BatteryHealth} a sucastne Message::body obsahuje {enum MessageBody::Version(Version), enum BatteryHealth(BatteryHealth) }
co ma za nasledok ze Serde serializuje Message(Version) nasledovne

Kód: [Vybrat]
0             1       2      3        4
[message_type | _pad0 | body_size     ]
[              crc                    ]
[              enum                   ]      <---- serde vlozil enum
[x1           |  x2   |     x3        ]

Takze "struct MessageHeader" ma dlzku 8 bajtov, "struct Version" ma dlzku 4 bajty => idealne by "struct Message" mal mat 12 bajtov.
V skutocnosti ma "struct Message" 16 bajtov, a to z dovodu ze serde prida 4 bajty na rozlisenie enum MessageBody::{Version, BatteryHealth}

Serializovany objekt s prihladnutim na kod vyzsie vyzera nasledovne, kde 11/22 je MessageBodyType::{Version, BatteryHealth}, a 0/1 na 9 pozicii je "enum MessageBody::{Version(), BatteryHealth()}"
Kód: [Vybrat]
serialized_version: (16) vec![11, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ...]
serialized_battery: (16) vec![22, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, ...]

 
Preto sa pytam skusenejsich, akceptovat to, ze serde prida 4bajty na rozlisenie enumu a tuto vec zohladit na strane klienta,
Pripadne, napada Vas moznost ako namodelovat kod nizsie, tak, aby serde/bincode serializovalo/deserializovalo iba mne chcenych 12bajtov (MessageHeader + MessageBody)

AD: Pokusal som sa namodelovat "pub fn deserialize<'a>(bytes: &'a [u8]) -> Box<MessageTrait>", toto sa mi nepodarilo skrz (https://doc.rust-lang.org/error-index.html#E0038)

Rust:
    cargo - serde
    cargo - bincode
Kód: [Vybrat]
use serde_repr::*;
use serde::{Deserialize, Serialize};

#[derive(Serialize, Deserialize, PartialEq, Debug)]
pub enum MessageBody {
    Version(Version),
    BatteryHealth(BatteryHealth),
}

#[derive(Serialize_repr, Deserialize_repr, PartialEq, Debug)]
#[repr(u8)]
pub enum MessageBodyType {
    Version = 11,
    BatteryHealth = 22,
}

impl MessageBody {
    pub fn value(&self) -> MessageBodyType {
        match *self {
            MessageBody::Version(_) => MessageBodyType::Version,
            MessageBody::BatteryHealth(_) => MessageBodyType::BatteryHealth
        }
    }
}

#[derive(Serialize, Deserialize, PartialEq, Debug)]
#[repr(C)]
pub struct MessageHeader {
    message_type: MessageBodyType,  // 1
    _pad0: u8,                      // 1
    body_size: u16,                 // 2
    crc: u32,                       // 4
}

impl MessageHeader {
  pub fn new_as(message_type: MessageBodyType) -> MessageHeader {
    MessageHeader {
        message_type: message_type,
        _pad0: 0,
        body_size: 0,
        crc: 0,
    }
  }
}

#[derive(Serialize, Deserialize, PartialEq, Debug)]
struct Message {
    header: MessageHeader,
    body: MessageBody,
}
impl Message {
    pub fn serialize(mt: MessageBody) -> Vec<u8> {
        let header = MessageHeader::new_as(mt.value());
        let header_size_of = std::mem::size_of::<MessageHeader>();
        let header_vec =  bincode::serialize(&header).unwrap();
        let header_vec_len = header_vec.len();


        let body_version_size_of = std::mem::size_of::<Version>();
        let body_vec: Vec<u8> = bincode::serialize(&mt).unwrap();
        let body_vec_vec_len = body_vec.len();


        let message: Message = Message { header:  header, body: mt };
        let message_size_of = std::mem::size_of::<Message>();
        let message_vec = bincode::serialize(&message).unwrap();
        let message_len = message_vec.len();
       
        message_vec
    }

    pub fn deserialize<'a>(bytes: &'a [u8]) -> Message {
        let message_header_len = std::mem::size_of::<MessageHeader>();

        let header_slice: &[u8] = &bytes[0..message_header_len];
        let header: MessageHeader = bincode::deserialize(header_slice).unwrap();

        let message: Message = bincode::deserialize(bytes).unwrap();

        message
    }
}

#[derive(Serialize, Deserialize, PartialEq, Debug)]
#[repr(C)]
pub struct Version {
    pub x1: u8,       // 1
    pub x2: u8,       // 1
    pub x3: u16,      // 2
}

#[derive(Serialize, Deserialize, PartialEq, Debug)]
#[repr(C)]
pub struct BatteryHealth {
    pub x1: u8,       // 1
    pub x2: u8,       // 1
    pub x3: u16,      // 2
}

fn main () -> Result<(), Box<(dyn std::error::Error + 'static)>> {
    let serialized_version: Vec<u8> = Message::serialize(MessageBody::Version(Version{x1: 3, x2: 6, x3: 0xFAFA}));
    let serialized_battery: Vec<u8> = Message::serialize(MessageBody::BatteryHealth(BatteryHealth{x1: 10, x2: 20, x3: 0x0A0A}));

    let deserialized_version: Message = Message::deserialize(&serialized_version);


  Ok(())
}

Diky M.

8
Hardware / Re:MMC karta - nieje mozne ju precitat
« kdy: 05. 12. 2021, 18:18:24 »
Kapacita je 16GB, logy mam default v Ubuntu 20.04, takze predpokladam ze ju nedetekoval :/

Mas viac detailov o tom postupe ?:) Celkom ma to zaujalo, pohladam co sa pise o sdkarte, uz som ju par krat riesil cez MCU ale este nie tymto sposobom .. vianoce budu dlhe :)

Keby si sa chcel podelit o takyto vyskum, mozeme doriesit kooperaciu (:

9
Hardware / Re:MMC karta - nieje mozne ju precitat
« kdy: 05. 12. 2021, 13:39:32 »
Karta je: Kingston 16GB Micro-SD HC, SDC10/16GB N0413-003 A00LF

10
Hardware / MMC karta - nieje mozne ju precitat
« kdy: 05. 12. 2021, 13:31:25 »
Ahojte, dostal som od znameho SDKartu, ktora sa tvari ze je mrtva. Bola povodne v telefone s Androidom (??? verzia) ktory je uz nefunkcny.
Hovoril nieco o tom, ze telefon si vyziadal PIN pre kartu - ja som tuto funkciu nenasiel/nepoznam ju, ale myslim si ze to nieje dovod aby to Linux nerozpoznal.

Napada Vas nejaka moznost ako precitat kartu? Linux ju rozoznal, tak este uplne mrtva nie je.
Kód: [Vybrat]
dmesg:
    usb 1-3: new high-speed USB device number 31 using xhci_hcd
    usb 1-3: New USB device found, idVendor=0bda, idProduct=0109, bcdDevice= 9.59
    usb 1-3: New USB device strings: Mfr=1, Product=2, SerialNumber=3
    usb 1-3: Product: USB2.0-CRW
    usb 1-3: Manufacturer: Generic
    usb 1-3: SerialNumber: 20090815198100000
    usb-storage 1-3:1.0: USB Mass Storage device detected
    scsi host9: usb-storage 1-3:1.0
    scsi 9:0:0:0: Direct-Access     Generic- SD/MMC           1.00 PQ: 0 ANSI: 0 CCS
    sd 9:0:0:0: Attached scsi generic sg1 type 0
    sd 9:0:0:0: [sdb] Attached SCSI removable disk
   
lsusb:
    Bus 001 Device 031: ID 0bda:0109 Realtek Semiconductor Corp. microSDXC Card Reader [Hama 00091047]

lsblk:
    Nothing
   
ls /dev/sg*
    /dev/sg1
   
ls /dev/sd*
    /dev/sdb
   
sudo fdisk /dev/sdb
    fdisk: cannot open /dev/sdb: No medium found

sudo dd if=/dev/sdb of=~/Temp/test.img
    dd: failed to open '/dev/sdb': No medium found
   
sudo sg_dd if=/dev/sg1 of=Temp/test.img2 bs=4M count=1024
    reading (SG_IO) on sg device, error: Invalid argument
    sg_read failed, at or after lba=0 [0x0]
    Some error occurred,  remaining block count=1024
    0+0 records in
    0+0 records out

11
Vývoj / Re:Rust - std::ANY alebo lepší návrh?
« kdy: 18. 11. 2021, 17:34:26 »
Očividně jsme se nepochopili, enum v Rustu je, jak správně poznamenal Idris, součtový typ, tedy něco jako variantní typ v jiných jazycích - můžeš na základě zvolené varianty (typicky pattern matching) vzít vnitřek (např. instanci struktury X, Y nebo Z) a pracovat s ním "hezky" namísto toho řešení, které jsi měl původně. Struktura a enum se v Rustu doplňují a to dost elegantně.

Tvoje nové řešení používá enum a la C, což není samozřejmě nic špatného, ale já jsem si představoval něco jiného - muselo by se to ale celé překopat. Jinak doporučuju se mrknout na Diesel a podobná řešení DB v Rustu - ať už pro náhradu nebo inspiraci.
Nakolko v tomto pripade sa mi jedna o navrh, tak reimplementacia do Rustovskeho Enumu je taka studijna vyzva :). Pozrem co ponuka doc rustu na Enum, pattern matching a pod. Postnem to sem na reviziu a pre porovnanie.

Diky za hint


12
Vývoj / Re:Rust - std::ANY alebo lepší návrh?
« kdy: 17. 11. 2021, 22:16:35 »
K tomu navrhu cez Lazy Init, super napad, rovno to pouzijem, uvazoval som ale nic lepsie ma prakticky na momentalne sksuenosti nenapada.
Jde to elegantněji přes get_or_insert.

Diky za hint, vyzera to ako tiez dobra cesta :)

13
Vývoj / Re:Rust - std::ANY alebo lepší návrh?
« kdy: 17. 11. 2021, 21:40:24 »
Dik za hint, mas pravdu, to s tym Option optimalizujem (:
K tomu navrhu cez Lazy Init, super napad, rovno to pouzijem, uvazoval som ale nic lepsie ma prakticky na momentalne sksuenosti nenapada.

Este raz dik za hint.

14
Vývoj / Re:Rust - std::ANY alebo lepší návrh?
« kdy: 17. 11. 2021, 12:47:14 »

Ano, spravne. Jednotlive typy (XYZ) poznam uz v dobe prekladu, nevedel som spravne namodelovat Trait tak, aby som vedel "nacpat" XYZ do funkcie "push", a teda, vyuzil som mne zname std::Any.
Proč nepoužiješ enum?
Este niesom v Ruste spravne "zabehnuty" takze, neviem/netusim ako konkretne by som pouzil Enum ako nahradu za Struct ( tomto konkretnom priklade)

fn push<T:B>(&mut self, data:T)

Ano, k tomuto som sa rovnako dopracoval +- ked ste to postol.

Posielam prehladnejsi, upravenejsi kod, samozrejme v kode pouzivam Result<(), Error>, len pre prehladnost som to odstranil.
Uz sa mi to vcelku pozdava, az na nutnost DatabaseMembers, ale to si myslim, ze casom a skusenostami optimalizujem :)
Diky

Kód: [Vybrat]
use MYSQL::Connection;

pub enum DatabaseMembers {
    X,
    Y,
    Z
}

// Various Structs
pub struct X {
    pub name: String
}

pub struct Y {
    pub text: String
}

pub struct Z {
    pub value: u64
}

/* Builder - traits */
trait DatabaseBuilder {
    fn push(&self, c: &Option<Connection>);
    fn create_table(c: &Option<Connection>);
}

impl DatabaseBuilder for X {
    fn push(&self, c: &Option<Connection>){
        let query = query = "INSERT INTO x (name) VALUES (?1)"
        let query_params = params![&self.name];

        match c {
            Some(e) => e.execute(query, query_params)?,
            None => {},
        };
    }

    fn create_table(c: &Option<Connection>){
        let query =
            "CREATE TABLE IF NOT EXISTS X (
                id      INTEGER PRIMARY KEY,
                name    TEXT NOT NULL,
            );";
        match c {
            Some(e) => e.execute(query, [])?,
            None => {},
        }
    }

}

impl DatabaseBuilder for Y {
    fn push(&self, c: &Option<Connection>){
        let query = query = "INSERT INTO y (text) VALUES (?1)"
        let query_params = params![&self.value];

        match c {
            Some(e) => e.execute(query, query_params)?,
            None => {},
        };
    }

    fn create_table(c: &Option<Connection>){
        let query =
            "CREATE TABLE IF NOT EXISTS X (
                id      INTEGER PRIMARY KEY,
                text    TEXT NOT NULL,
            );";
        match c {
            Some(e) => e.execute(query, [])?,
            None => {},
        }
    }
}

impl DatabaseBuilder for Z {
    fn push(&self, c: &Option<Connection>){
        let query = query = "INSERT INTO z (name) VALUES (?1)"
        let query_params = params![&self.name];

        match c {
            Some(e) => e.execute(query, query_params)?,
            None => {},
        };
    }

    fn create_table(c: &Option<Connection>){
        let query =
            "CREATE TABLE IF NOT EXISTS X (
                id      INTEGER PRIMARY KEY,
                name    INTEGER,
            );";
        match c {
            Some(e) => e.execute(query, [])?,
            None => {},
        }
    }
}

impl DatabaseBuilder for Database {
    fn push(&self, c: &Option<Connection>){};
    fn create_table(c: &Option<Connection>){};
}

/* Database */
pub struct Database {
    c: Option<Connection>,
}

impl Database {
    pub fn new() -> Database {
        Database {
            c: None,
        }
    }

    pub fn open_temporary(&mut self){
        self.c = Some(Connection::open_in_memory());
    }

    pub fn push<T: DatabaseBuilder>(&mut self, data: &T) {
        data.push(&self.conn)
    }

    pub fn create_table(&mut self, m: DatabaseMembers) {
        match m {
            DatabaseMembers::X => X::create_table(&self.conn),
            DatabaseMembers::Y => Y::create_table(&self.conn),
            DatabaseMembers::Z => Z::create_table(&self.conn),
        }
    }
}

fn main() {

    let mut db: Database = Database::new();
    db.open_temporary();


    // X   
    db.create_table(DatabaseMembers::X);
    let x = X {name: String::from("Ahoj")};
    db.push(&x);

    // Y   
    db.create_table(DatabaseMembers::Y);
    let y = Y {text: String::from("Ahoj")};
    db.push(&y);

}



15
Vývoj / Re:Rust - std::ANY alebo lepší návrh?
« kdy: 15. 11. 2021, 23:20:51 »
Mozete spravit kratky snippet, pripadne upravit kod ktory som postol? Nieje mi uplne jasne ako by som to v oboch pripadoch zrealizoval.. v Ruste som novacik tak sa rad naucim novym trikom.
Diky!

Stran: [1] 2 3