dochy_diff 0.10.1

Calculates Dochy Diff.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82

use dochy_compaction::kval_enum::KVal;
use std::collections::BTreeMap;
use dochy_core::structs::{ MetaTable, Qv, VarType, QvType, MetaValue};
use crate::imp::write::store_ids::{store_ids_ref, StoredIDs};
use dochy_compaction::basic_compaction::{comp_str};
use crate::diff_error::DiffError;
use crate::imp::write::write_store_ids::write_stored_ids;

pub(crate) fn write_refs(refs : &BTreeMap<usize, &Qv<String>>, meta : &MetaTable, r : &mut Vec<KVal>) -> Result<(), DiffError>{
    let ids = store_ids_ref(refs);
    write_stored_ids(&ids, r);
    match ids{
        StoredIDs::Zero =>{
            Ok(())
        },
        _ =>{
            write_refs2(refs, meta, r)?;
            Ok(())
        },
    }
}

pub(crate) fn write_refs2(refs : &BTreeMap<usize, &Qv<String>>, meta : &MetaTable, r : &mut Vec<KVal>) -> Result<(), DiffError> {
    for (&id, &qv) in refs {
        let p = if let Some((_, MetaValue::Param(p))) = meta.get(id) { p } else { unreachable!("invalid meta") };
        match p.var_type() {
            VarType::Normal => {
                write_val(qv, r)?;
            },
            VarType::Nullable => {
                match qv.qv_type() {
                    QvType::Val => {
                        r.push(KVal::Bit(true));
                        write_val(qv, r)?;
                    },
                    QvType::Null => {
                        r.push(KVal::Bit(false));
                    },
                    QvType::Undefined => { Err("invalid undefined")? }
                }
            },
            VarType::Undefiable => {
                match qv.qv_type() {
                    QvType::Val => {
                        r.push(KVal::Bit(true));
                        write_val(qv, r)?;
                    },
                    QvType::Undefined => {
                        r.push(KVal::Bit(false));
                    },
                    QvType::Null => { Err("invalid null")? }
                }
            },
            VarType::UndefNullable => {
                match qv.qv_type() {
                    QvType::Val => {
                        r.push(KVal::Bit(true));
                        write_val(qv, r)?;
                    },
                    QvType::Null => {
                        r.push(KVal::Bit(false));
                        r.push(KVal::Bit(true));
                    },
                    QvType::Undefined => {
                        r.push(KVal::Bit(false));
                        r.push(KVal::Bit(false));
                    },
                }
            }
        }
    }
    Ok(())
}

fn write_val(s : &Qv<String>, r : &mut Vec<KVal>) -> Result<(), DiffError>{
    if let Qv::Val(s) = s {
        r.push(comp_str(s.to_string()));
        Ok(())
    } else{
        Err("must be val write_refs::write_value")?
    }
}