encoding/encerr

import encoding.encerr
import encoding.json
import str

func where(text: str, pos: int): str:
    mut line := 1
    mut col := 1
    repeat pos in i:
        if text.substr(i, 1) == "\n":
            line += 1
            col = 1
        else:
            col += 1
        end
    end
    ret "line " + str.FromInt(line) + ", column " + str.FromInt(col)
end

func main:
    text := `{
  "name": "shop",
  "port": 8080
  "debug": true
}`
    mut e := encerr.NoError()
    _ := json.Decode(text, e)
    if encerr.IsError(e):
        println "settings.json:", where(text, e.position) + ":", e.message
    end
end

import encoding.encerr
import encoding.json
import encoding.envfile
import encoding.msgpack
import encoding.value
import compress

struct Limits:
    pub max_users: int = 0
    pub max_storage_gb: int = 0
end

func report(source: str, e: encerr.EncodingError):
    if not encerr.IsError(e):
        println source, "ok"
        ret
    end
    mut what := "bad input"
    if e.kind == encerr.KindUnexpectedEOF:
        what = "cut off"
    else e.kind == encerr.KindTrailingData:
        what = "extra data after the end"
    else e.kind == encerr.KindCustom:
        what = "not supported"
    end
    println source, what, "at byte", e.position, "(" + e.message + ")"
end

func main:
    mut e := encerr.NoError()
    mut lim := Limits {}
    _ := json.Unmarshal(`{"max_users": "fifty", "max_storage_gb": 20}`, lim, e)
    report("limits.json:", e)

    e = encerr.NoError()
    _ := json.Decode(`{"plan": "team"} {"plan": "pro"}`, e)
    report("plan.json:  ", e)

    e = encerr.NoError()
    mut env := envfile.ParseStrict("PLAN=team\nSEATS=\"12\n", e)
    report(".env:       ", e)
    envfile.Free(env)

    mut obj := value.NewValueObject()
    value.ObjectSet(obj, "seats", value.ValueInt(12))
    bytes := msgpack.Marshal(obj)
    e = encerr.NoError()
    _ := msgpack.UnmarshalBytes(bytes.data, compress.BufLen(bytes) - 1, e)
    report("cache.bin:  ", e)

    _ := msgpack.Unmarshal(bytes, e)
    report("stale error:", e)
    e = encerr.NoError()
    back := msgpack.Unmarshal(bytes, e)
    report("after reset:", e)
    println "seats:", value.AsInt(value.ObjectGet(back, "seats"))
end

import encoding.encerr

struct Size:
    pub w: int = 0
    pub h: int = 0
end

func parse_size(text: str, out &: Size, err &: encerr.EncodingError): bool:
    x := text.find("x")
    if x < 0:
        err = encerr.ErrUnexpectedEOF(text.len())
        ret false
    end
    w := text.substr(0, x)
    h := text.substr(x + 1, text.len() - x - 1)
    if w == "" or h == "":
        err = encerr.ErrUnexpectedToken("expected a number on both sides of 'x'", x)
        ret false
    end
    out.w = w.to_int()
    out.h = h.to_int()
    if out.w <= 0 or out.h <= 0:
        err = encerr.NewError(encerr.KindCustom, "sizes must be positive", 0)
        ret false
    end
    ret true
end

func main:
    inputs := ["1920x1080", "800", "x600", "0x10"]
    each s in inputs:
        mut size := Size {}
        mut e := encerr.NoError()
        if parse_size(s, size, e):
            println s, "->", size.w, "by", size.h
        else e.kind == encerr.KindUnexpectedEOF:
            println s, "-> incomplete:", e.message
        else:
            println s, "-> kind", e.kind, "at byte", e.position
            println "   ", e.message
        end
    end
end