diff --git a/adgangsadressse.go b/adgangsadressse.go new file mode 100644 index 0000000..f075dd3 --- /dev/null +++ b/adgangsadressse.go @@ -0,0 +1,106 @@ +package dawa + +// En adgangsadresse er en struktureret betegnelse som angiver en særskilt +// adgang til et areal eller en bygning efter reglerne i adressebekendtgørelsen. +// +// Forskellen på en adresse og en adgangsadresse er at adressen rummer +// eventuel etage- og/eller dørbetegnelse. Det gør adgangsadressen ikke. +type AdgangsAdresse struct { + DDKN DDKN `json:"DDKN"` // Adressens placering i Det Danske Kvadratnet (DDKN). + Adgangspunkt Adgangspunkt `json:"adgangspunkt"` // Geografisk punkt, som angiver særskilt adgang fra navngiven vej ind på et areal eller bygning. + Ejerlav Ejerlav `json:"ejerlav"` // Det matrikulære ejerlav som adressen ligger i. + EsrEjendomsNr string `json:"esrejendomsnr"` // ESR Ejendomsnummer. Indtil 7 cifre. + Historik Historik `json:"historik"` // Væsentlige tidspunkter for adgangsadressen + Href string `json:"href"` // Adgangsadressens URL. + Husnr string `json:"husnr"` // Husnummer. Max 4 cifre eventuelt med et efterfølgende bogstav. + ID string `json:"id"` // Adgangsadressens unikke id, f.eks. 0a3f5095-45ec-32b8-e044-0003ba298018 + Kommune Kommune `json:"kommune"` // Kommunen som adressen er beliggende i. + Kvh string `json:"kvh"` // KVH-nøgle. 12 tegn bestående af 4 cifre der repræsenterer kommunekode, 4 cifre der repræsenterer vejkode efterfulgt af 4 tegn der repræsenter husnr + Matrikelnr string `json:"matrikelnr"` // Matrikelnummer. Unikt indenfor et ejerlav. + Opstillingskreds Opstillingskreds `json:"opstillingskreds"` // Opstillingskresen som adressen er beliggende i. Beregnes udfra adgangspunktet og opstillingskredsinddelingerne fra DAGI + Politikreds Politikreds `json:"politikreds"` // Politikredsen som adressen er beliggende i. Beregnes udfra adgangspunktet og politikredsinddelingerne fra DAGI + Postnummer PostnummerRef `json:"postnummer"` // Postnummeret som adressen er beliggende i. + Region Region `json:"region"` // Regionen som adressen er beliggende i. Beregnes udfra adgangspunktet og regionsinddelingerne fra DAGI + Retskreds Retskreds `json:"retskreds"` // Retskredsen som adressen er beliggende i. Beregnes udfra adgangspunktet og retskredsinddelingerne fra DAGI + Sogn Sogn `json:"sogn"` // Sognet som adressen er beliggende i. Beregnes udfra adgangspunktet og sogneinddelingerne fra DAGI + Status int `json:"status"` //Adressens status, som modtaget fra BBR. "1" angiver en endelig adresse og "3" angiver en foreløbig adresse". Adresser med status "2" eller "4" er ikke med i DAWA. + SupplerendeBynavn string `json:"supplerendebynavn"` // Et supplerende bynavn – typisk landsbyens navn – eller andet lokalt stednavn, der er fastsat af kommunen for at præcisere adressens beliggenhed indenfor postnummeret. + Vejstykke VejstykkeRef `json:"vejstykke"` // Vejstykket som adressen er knyttet til. + Zone string `json:"zone"` // Hvilken zone adressen ligger i. "Byzone", "Sommerhusområde" eller "Landzone". Beregnes udfra adgangspunktet og zoneinddelingerne fra PlansystemDK +} + +// Adressens placering i Det Danske Kvadratnet (DDKN). +type DDKN struct { + Km1 string `json:"km1"` + Km10 string `json:"km10"` + M100 string `json:"m100"` +} + +// Geografisk punkt, som angiver særskilt adgang fra navngiven vej ind på et areal eller bygning. +type Adgangspunkt struct { + Kilde int `json:"kilde"` // Kode der angiver kilden til adressepunktet. Et tegn. ”1” = oprettet maskinelt fra teknisk kort; ”2” = Oprettet maskinelt fra af matrikelnummer tyngdepunkt; ”3” = Eksternt indberettet af konsulent på vegne af kommunen; ”4” = Eksternt indberettet af kommunes kortkontor o.l. ”5” = Oprettet af teknisk forvaltning." + Koordinater []float64 `json:"koordinater"` // Adgangspunktets koordinater som array [x,y]. *sic* + Nøjagtighed string `json:"nøjagtighed"` // Kode der angiver nøjagtigheden for adressepunktet. Et tegn. ”A” betyder at adressepunktet er absolut placeret på et detaljeret grundkort, tyisk med en nøjagtighed bedre end +/- 2 meter. ”B” betyder at adressepunktet er beregnet – typisk på basis af matrikelkortet, således at adressen ligger midt på det pågældende matrikelnummer. I så fald kan nøjagtigheden være ringere en end +/- 100 meter afhængig af forholdene. ”U” betyder intet adressepunkt. + Tekniskstandard string `json:"tekniskstandard"` // Kode der angiver den specifikation adressepunktet skal opfylde. 2 tegn. ”TD” = 3 meter inde i bygningen ved det sted hvor indgangsdør e.l. skønnes placeret; ”TK” = Udtrykkelig TK-standard: 3 meter inde i bygning, midt for længste side mod vej; ”TN” Alm. teknisk standard: bygningstyngdepunkt eller blot i bygning; ”UF” = Uspecificeret/foreløbig: ikke nødvendigvis placeret i bygning." + Tekstretning float64 `json:"tekstretning"` // Angiver en evt. retningsvinkel for adressen i ”gon” dvs. hvor hele cirklen er 400 gon og 200 er vandret. Værdier 0.00-400.00: Eksempel: ”128.34”. + Ændret AwsTime `json:"ændret"` // Dato for sidste ændring i adressepunktet, som registreret af BBR. +} + +type Ejerlav struct { + Kode int `json:"kode"` // Unik identifikation af det matrikulære ”ejerlav”, som adressen ligger i. Repræsenteret ved indtil 7 cifre. Eksempel: ”170354” for ejerlavet ”Eskebjerg By, Bregninge”. + Navn string `json:"navn"` // Det matrikulære ”ejerlav”s navn. Eksempel: ”Eskebjerg By, Bregninge”. +} + +type Historik struct { + Oprettet AwsTime `json:"oprettet"` // Dato og tid for data oprettelse, + Ændret AwsTime `json:"ændret"` // Dato og tid hvor der sidst er ændret i data, +} + +// Kommunen som adressen er beliggende i. +type Kommune struct { + Href string `json:"href"` // Kommunens unikke URL. + Kode string `json:"kode"` // Kommunekoden. 4 cifre. + Navn string `json:"navn"` // Kommunens navn. +} + +type Opstillingskreds struct { + Href string `json:"href"` // Opstillingskredsens unikke URL + Kode string `json:"kode"` // Identifikation af opstillingskredsen. + Navn string `json:"navn"` // Opstillingskredsens navn. +} + +type Politikreds struct { + Href string `json:"href"` // Politikredsens unikke URL + Kode string `json:"kode"` // Identifikation af politikredsen + Navn string `json:"navn"` // Politikredsens navn +} + +type PostnummerRef struct { + Href string `json:"href"` // Postnummerets unikke URL + Navn string `json:"navn"` // Det navn der er knyttet til postnummeret, typisk byens eller bydelens navn. Repræsenteret ved indtil 20 tegn. Eksempel: ”København NV”. + Nr string `json:"nr"` // Postnummer. 4 cifre +} + +type Region struct { + Href string `json:"href"` // Regionens unikke URL + Kode string `json:"kode"` // Identifikation af regionen + Navn string `json:"navn"` // Regionens navn +} + +type Retskreds struct { + Href string `json:"href"` // Retskredsens unikke URL + Kode string `json:"kode"` // Identifikation af retskredsen + Navn string `json:"navn"` // Retskredsens navn +} + +type Sogn struct { + Href string `json:"href"` // Sognets unikke URL + Kode string `json:"kode"` // Identifikation af sognet + Navn string `json:"navn"` // Sognets navn +} + +type VejstykkeRef struct { + Href string `json:"href"` + Kode string `json:"kode"` // Vejkoden. 4 cifre. + Navn string `json:"navn"` // Vejnavn. Der skelnes mellem store og små bogstaver. +} diff --git a/adresse.go b/adresse.go new file mode 100644 index 0000000..67b2cc8 --- /dev/null +++ b/adresse.go @@ -0,0 +1,13 @@ +package dawa + +type Adresse struct { + Adgangsadresse AdgangsAdresse `json:"adgangsadresse"` // Adressens adgangsadresse + Adressebetegnelse string `json:"adressebetegnelse"` // (unknown) + Dør string `json:"dør"` // Dørbetegnelse. Tal fra 1 til 9999, små og store bogstaver samt tegnene / og -. + Etage string `json:"etage"` // Etagebetegnelse. Hvis værdi angivet kan den antage følgende værdier: tal fra 1 til 99, st, kl, kl2 op til kl9. + Historik Historik `json:"historik"` // Væsentlige tidspunkter for adressen + Href string `json:"href"` // Adgangsadressens URL. + ID string `json:"id"` // Adressens unikke id, f.eks. 0a3f5095-45ec-32b8-e044-0003ba298018. + Kvhx string `json:"kvhx"` // KVHX-nøgle. 19 tegn bestående af 4 cifre der repræsenterer kommunekode, 4 cifre der repræsenterer vejkode, 4 tegn der repræsenter husnr, 3 tegn der repræsenterer etage og 4 tegn der repræsenter dør. + Status int `json:"status"` // Adressens status. 1 indikerer en gældende adresse, 3 indikerer en foreløbig adresse. +} diff --git a/awstime.go b/awstime.go new file mode 100644 index 0000000..a58bf8e --- /dev/null +++ b/awstime.go @@ -0,0 +1,97 @@ +package dawa + +import ( + "encoding/gob" + "strings" + "time" +) + +// Since this is not a standard encoded field, we must create out own type. +type AwsTime time.Time + +var location *time.Location + +func init() { + var err error + location, err = time.LoadLocation("Europe/Copenhagen") + if err != nil { + panic(err) + } + // Register it as Gob + gob.Register(AwsTime{}) +} + +// ParseTime will return the time encoding for a single field +// It the input must be AWS formatted encoding +func ParseTime(s string) (*AwsTime, error) { + result, err := time.ParseInLocation("2006-01-02T15:04:05.000", string(s), location) + if err != nil { + return nil, err + } + t := AwsTime(result) + return &t, nil +} + +func (t AwsTime) MarshalText() (text []byte, err error) { + return t.MarshalJSON() +} + +func (t *AwsTime) UnmarshalText(text []byte) error { + return t.UnmarshalJSON(text) +} + +// UnmarshalJSON a single time field +// It will attempt AWS encoding, and if that fails standard UnmarshalJSON for time.Time +func (t *AwsTime) UnmarshalJSON(b []byte) error { + unquoted := strings.Trim(string(b), "\"") + result, err := time.ParseInLocation("2006-01-02T15:04:05.000", unquoted, location) + + // Could not parse, attempt standard unmarshall + if err != nil { + var t2 time.Time + err = t2.UnmarshalJSON([]byte(unquoted)) + if err != nil { + return err + } + *t = AwsTime(t2) + return nil + } + + *t = AwsTime(result) + return nil +} + +// Time will return the underlying time.Time object +func (t AwsTime) Time() time.Time { + return time.Time(t) +} + +// MarshalJSON will send it as ordinary Javascipt date +func (t AwsTime) MarshalJSON() ([]byte, error) { + return time.Time(t).MarshalJSON() +} + +// GobEncode (as time.Time) +func (t AwsTime) GobEncode() ([]byte, error) { + return time.Time(t).GobEncode() +} + +// GobDecode (as time.Time) +func (t *AwsTime) GobDecode(data []byte) error { + return (*time.Time)(t).GobDecode(data) +} + +/* +// GetBSON provides BSON encoding of the Kid +func (t AwsTime) GetBSON() (interface{}, error) { + return time.Time(t), nil +} + +// SetBSON provides BSON decoding +func (t *AwsTime) SetBSON(raw bson.Raw) error { + var t2 time.Time + err := raw.Unmarshal(&t2) + *t = AwsTime(t2) + return errgo.Mask(err) +} +*/ diff --git a/examples/adgangs-adresser-json.go b/examples/adgangs-adresser-json.go new file mode 100644 index 0000000..2e4649b --- /dev/null +++ b/examples/adgangs-adresser-json.go @@ -0,0 +1,36 @@ +package main + +import ( + "github.com/klauspost/dawa" + "io" + "log" + "os" + "time" +) + +func main() { + file, err := os.Open("adgangsadresser.json") // For read access. + if err != nil { + log.Fatal(err) + } + + iter, err := aws.ImportAdgangsAdresserJSON(file) + if err != nil { + log.Fatal(err) + } + + n := 0 + t := time.Now() + for { + a, err := iter.Next() + if err == io.EOF { + log.Printf("Finished reading %d entries in %v.\n", n, time.Now().Sub(t)) + return + } + if err != nil { + log.Fatal(err) + } + n++ + log.Printf("Entry:%#v\n", a) + } +} diff --git a/examples/adgangsadresser-csv.go b/examples/adgangsadresser-csv.go new file mode 100644 index 0000000..67e2349 --- /dev/null +++ b/examples/adgangsadresser-csv.go @@ -0,0 +1,36 @@ +package main + +import ( + "github.com/klauspost/dawa" + "io" + "log" + "os" + "time" +) + +func main() { + file, err := os.Open("adgangsadresser.csv") // For read access. + if err != nil { + log.Fatal(err) + } + + iter, err := aws.ImportAdgangsAdresserCSV(file) + if err != nil { + log.Fatal(err) + } + + n := 0 + t := time.Now() + for { + a, err := iter.Next() + if err == io.EOF { + log.Printf("Finished reading %d entries in %v.\n", n, time.Now().Sub(t)) + return + } + if err != nil { + log.Fatal(err) + } + n++ + log.Printf("Entry:%#v\n", a) + } +} diff --git a/examples/adgangsadresser-json.go b/examples/adgangsadresser-json.go new file mode 100644 index 0000000..2e4649b --- /dev/null +++ b/examples/adgangsadresser-json.go @@ -0,0 +1,36 @@ +package main + +import ( + "github.com/klauspost/dawa" + "io" + "log" + "os" + "time" +) + +func main() { + file, err := os.Open("adgangsadresser.json") // For read access. + if err != nil { + log.Fatal(err) + } + + iter, err := aws.ImportAdgangsAdresserJSON(file) + if err != nil { + log.Fatal(err) + } + + n := 0 + t := time.Now() + for { + a, err := iter.Next() + if err == io.EOF { + log.Printf("Finished reading %d entries in %v.\n", n, time.Now().Sub(t)) + return + } + if err != nil { + log.Fatal(err) + } + n++ + log.Printf("Entry:%#v\n", a) + } +} diff --git a/examples/adresser-csv.go b/examples/adresser-csv.go new file mode 100644 index 0000000..a29c1c5 --- /dev/null +++ b/examples/adresser-csv.go @@ -0,0 +1,35 @@ +package main + +import ( + "github.com/klauspost/dawa" + "io" + "log" + "os" + "time" +) + +func main() { + file, err := os.Open("adresser.csv") // For read access. + if err != nil { + log.Fatal(err) + } + + iter, err := aws.ImportAdresserCSV(file) + if err != nil { + log.Fatal(err) + } + n := 0 + t := time.Now() + for { + a, err := iter.Next() + if err == io.EOF { + log.Printf("Finished reading %d entries in %v.\n", n, time.Now().Sub(t)) + return + } + if err != nil { + log.Fatal(err) + } + n++ + log.Printf("Entry:%s\n", a.ID) + } +} diff --git a/examples/adresser-json.go b/examples/adresser-json.go new file mode 100644 index 0000000..36da568 --- /dev/null +++ b/examples/adresser-json.go @@ -0,0 +1,43 @@ +package main + +import ( + "fmt" + "github.com/klauspost/dawa" + "io" + "log" + "os" + "time" +) + +func main() { + file, err := os.Open("adresser.json") // For read access. + if err != nil { + log.Fatal(err) + } + + iter, err := dawa.ImportAdresserJSON(file) + if err != nil { + log.Fatal(err) + } + + n := 0 + t := time.Now() + t2 := time.Now() + for { + a, err := iter.Next() + if err == io.EOF { + log.Printf("Finished reading %d entries in %v.\n", n, time.Now().Sub(t)) + return + } + if err != nil { + log.Fatal(err) + } + n++ + if n%1000 == 0 { + fmt.Printf("Processed %d, last 1000 was %.1f per sec.\n", n, (float64)(time.Second*1000)/float64(time.Now().Sub(t2))) + t2 = time.Now() + } + _ = a + //fmt.Printf("Item:%#v\n", a) + } +} diff --git a/examples/examples.7z b/examples/examples.7z new file mode 100644 index 0000000..a06091e Binary files /dev/null and b/examples/examples.7z differ diff --git a/examples/postnumre-json.go b/examples/postnumre-json.go new file mode 100644 index 0000000..cdea91b --- /dev/null +++ b/examples/postnumre-json.go @@ -0,0 +1,36 @@ +package main + +import ( + "github.com/klauspost/dawa" + "io" + "log" + "os" + "time" +) + +func main() { + file, err := os.Open("postnumre.json") // For read access. + if err != nil { + log.Fatal(err) + } + + iter, err := aws.ImportPostnumreJSON(file) + if err != nil { + log.Fatal(err) + } + + n := 0 + t := time.Now() + for { + a, err := iter.Next() + if err == io.EOF { + log.Printf("Finished reading %d entries in %v.\n", n, time.Now().Sub(t)) + return + } + if err != nil { + log.Fatal(err) + } + n++ + log.Printf("Entry:%#v\n", a) + } +} diff --git a/examples/running.txt b/examples/running.txt new file mode 100644 index 0000000..0b7ed99 --- /dev/null +++ b/examples/running.txt @@ -0,0 +1,22 @@ + +Installing dependencies: + +go get github.com/klauspost/dawa/examples/... + + +Running web example: +go run webapi.go + +Run file import examples: + +1) Unpack files in examples.7z + +2) Run the file you would like to test: + +go run adgangsadresser-csv.go +go run adgangsadresser-json.go +go run adgangs-adresser-json.go +go run adresser-csv.go +go run adresser-json.go +go run postnumre-json.go +go run vejstykker-json.go diff --git a/examples/vejstykker-json.go b/examples/vejstykker-json.go new file mode 100644 index 0000000..4e3adb7 --- /dev/null +++ b/examples/vejstykker-json.go @@ -0,0 +1,36 @@ +package main + +import ( + "github.com/klauspost/dawa" + "io" + "log" + "os" + "time" +) + +func main() { + file, err := os.Open("vejstykker.json") // For read access. + if err != nil { + log.Fatal(err) + } + + iter, err := aws.ImportVejstykkerJSON(file) + if err != nil { + log.Fatal(err) + } + + n := 0 + t := time.Now() + for { + a, err := iter.Next() + if err == io.EOF { + log.Printf("Finished reading %d entries in %v.\n", n, time.Now().Sub(t)) + return + } + if err != nil { + log.Fatal(err) + } + n++ + log.Printf("Entry:%#v\n", a) + } +} diff --git a/examples/webapi.go b/examples/webapi.go new file mode 100644 index 0000000..04f0a04 --- /dev/null +++ b/examples/webapi.go @@ -0,0 +1,42 @@ +package main + +import ( + "encoding/json" + "fmt" + "github.com/davecgh/go-spew/spew" + "github.com/klauspost/dawa" + "io/ioutil" + "net/http" +) + +// Uses spew for nicer formatting of output, to use, execute: +// +// go get github.com/davecgh/go-spew/spew +// +// to install. +func main() { + // Get an address + resp, err := http.Get("http://dawa.aws.dk/adresser/0a3f509d-07be-32b8-e044-0003ba298018") + + if err != nil { + panic(err) + } + defer resp.Body.Close() + + // Read the response into r + r, err := ioutil.ReadAll(resp.Body) + if err != nil { + panic(err) + } + + // Create destination and decode the response + add := dawa.Adresse{} + err = json.Unmarshal(r, &add) + if err != nil { + panic(err) + } + + // We got the response. Print it. + fmt.Printf("JSON response:%s\nDecoded:\n", string(r)) + spew.Dump(add) +} diff --git a/generate.go b/generate.go new file mode 100644 index 0000000..b916344 --- /dev/null +++ b/generate.go @@ -0,0 +1,3 @@ +package dawa + +//go:generate codecgen -o values.generated.go postnummer.go awstime.go adresse.go adgangsadressse.go vejstykke.go diff --git a/helpers.go b/helpers.go new file mode 100644 index 0000000..1fa1129 --- /dev/null +++ b/helpers.go @@ -0,0 +1,25 @@ +package dawa + +import ( + "io" +) + +// readByteSkippingSpace() reads through an io.Reader until a character that is +// not whitespace is encountered +func readByteSkippingSpace(r io.Reader) (b byte, err error) { + buf := make([]byte, 1) + for { + _, err := r.Read(buf) + if err != nil { + return 0, err + } + b := buf[0] + switch b { + // Only handling ASCII white space for now + case ' ', '\t', '\n', '\v', '\f', '\r': + continue + default: + return b, nil + } + } +} diff --git a/import-adgangsadresser.go b/import-adgangsadresser.go new file mode 100644 index 0000000..fcf3214 --- /dev/null +++ b/import-adgangsadresser.go @@ -0,0 +1,175 @@ +package dawa + +import ( + "bufio" + "encoding/csv" + "github.com/ugorji/go/codec" + "io" + "strconv" +) + +// AdgangsAdresse is an Iterator that enable you to get individual entries. +type AdgangsAdresseIter struct { + a chan AdgangsAdresse + err error +} + +// Next will return addresses. +// It will return an error if that has been encountered. +// When there are not more entries nil, io.EOF will be returned. +func (a *AdgangsAdresseIter) Next() (*AdgangsAdresse, error) { + v, ok := <-a.a + if ok { + return &v, nil + } + return nil, a.err +} + +// ImportAdresserCSV will import "adresser" from a CSV file, supplied to the reader. +// An iterator will be returned that return all addresses. +func ImportAdgangsAdresserCSV(in io.Reader) (*AdgangsAdresseIter, error) { + r := csv.NewReader(in) + r.Comma = ',' + + // Read first line as headers + name, err := r.Read() + if err != nil { + return nil, err + } + + ret := &AdgangsAdresseIter{a: make(chan AdgangsAdresse, 100)} + if err != nil { + return nil, err + } + go func() { + defer close(ret.a) + v := make(map[string]string, len(name)) + for { + records, err := r.Read() + if err != nil { + ret.err = err + return + } + // Map to indexes, so we don't rely on index numbers, but on column names. + for j := range records { + v[name[j]] = records[j] + } + // PROCESS: id,status,oprettet,ændret,vejkode,vejnavn,husnr,etage,dør,supplerendebynavn + a := AdgangsAdresse{} + a.ID = v["id"] + a.Status, err = strconv.Atoi(v["status"]) + if err != nil { + ret.err = err + return + } + + // Example 2000-02-16T21:58:33.000 + o, err := ParseTime(v["oprettet"]) + if err != nil { + ret.err = err + return + } + a.Historik.Oprettet = *o + + o, err = ParseTime(v["ændret"]) + if err != nil { + ret.err = err + return + } + a.Historik.Ændret = *o + + a.Vejstykke.Kode = v["vejkode"] + a.Vejstykke.Navn = v["vejnavn"] + a.Husnr = v["husnr"] + a.SupplerendeBynavn = v["supplerendebynavn"] + a.Postnummer.Nr = v["postnr"] + a.Postnummer.Navn = v["postnrnavn"] + a.Kommune.Kode = v["kommunekode"] + a.Kommune.Navn = v["kommunenavn"] + a.Ejerlav.Kode, _ = strconv.Atoi(v["ejerlavkode"]) + a.Ejerlav.Navn = v["ejerlavnavn"] + a.Matrikelnr = v["matrikelnr"] + a.EsrEjendomsNr = v["esrejendomsnr"] + // ???? + // x,_ = strconv.ParseFloat("etrs89koordinat_øst") + // x,_ = strconv.ParseFloat("etrs89koordinat_nord") + a.Adgangspunkt.Koordinater = make([]float64, 2) + a.Adgangspunkt.Koordinater[0], _ = strconv.ParseFloat(v["wgs84koordinat_bredde"], 64) + a.Adgangspunkt.Koordinater[1], _ = strconv.ParseFloat(v["wgs84koordinat_længde"], 64) + + a.Adgangspunkt.Nøjagtighed = v["nøjagtighed"] + a.Adgangspunkt.Kilde, _ = strconv.Atoi(v["nøjagtighed"]) + a.Adgangspunkt.Tekniskstandard = v["tekniskstandard"] + a.Adgangspunkt.Tekstretning, _ = strconv.ParseFloat(v["tekstretning"], 64) + a.DDKN.M100 = v["ddkn_m100"] + a.DDKN.Km1 = v["ddkn_km1"] + a.DDKN.Km10 = v["ddkn_km10"] + o, err = ParseTime(v["adressepunktændringsdato"]) + if err != nil { + ret.err = err + return + } + a.Adgangspunkt.Ændret = *o + a.Region.Kode = v["regionskode"] + a.Region.Navn = v["regionsnavn"] + a.Sogn.Kode = v["sognekode"] + a.Sogn.Navn = v["sognenavn"] + a.Politikreds.Kode = v["politikredskode"] + a.Politikreds.Navn = v["politikredsnavn"] + a.Retskreds.Kode = v["retskredskode"] + a.Retskreds.Navn = v["retskredsnavn"] + + // opstilli ngskredskode,opstillingskredsnavn,zone + a.Opstillingskreds.Kode = v["opstillingskredskode"] + a.Opstillingskreds.Navn = v["opstillingskredsnavn"] + a.Zone = v["zone"] + ret.a <- a + } + }() + return ret, nil +} + +// ImportAdresserJSON will import "adresser" from a JSON input, supplied to the reader. +// An iterator will be returned that return all addresses. +func ImportAdgangsAdresserJSON(in io.Reader) (*AdgangsAdresseIter, error) { + reader := bufio.NewReader(in) + // Skip until after '[' + _, err := reader.ReadBytes('[') + if err != nil { + return nil, err + } + // Start decoder + ret := &AdgangsAdresseIter{a: make(chan AdgangsAdresse, 100)} + go func() { + defer close(ret.a) + var h codec.JsonHandle + h.ErrorIfNoField = true + for { + var dec *codec.Decoder = codec.NewDecoder(reader, &h) + a := AdgangsAdresse{} + if err := dec.Decode(&a); err != nil { + ret.err = err + return + } + ret.a <- a + + // Skip comma + if b, err := readByteSkippingSpace(reader); err != nil { + ret.err = err + return + } else { + switch b { + case ',': + continue + case ']': + ret.err = io.EOF + return + default: + panic("Invalid character in JSON data: " + string([]byte{b})) + } + } + + } + }() + return ret, nil +} diff --git a/import-adresser.go b/import-adresser.go new file mode 100644 index 0000000..b382cdd --- /dev/null +++ b/import-adresser.go @@ -0,0 +1,198 @@ +package dawa + +import ( + "bufio" + "encoding/csv" + "github.com/ugorji/go/codec" + "io" + "strconv" +) + +// AdresseIter is an Iterator that enable you to get individual entries. +type AdresseIter struct { + a chan Adresse + err error +} + +// Next will return addresses. +// It will return an error if that has been encountered. +// When there are not more entries nil, io.EOF will be returned. +func (a *AdresseIter) Next() (*Adresse, error) { + v, ok := <-a.a + if ok { + return &v, nil + } + return nil, a.err +} + +// ImportAdresserCSV will import "adresser" from a CSV file, supplied to the reader. +// An iterator will be returned that return all addresses. +func ImportAdresserCSV(in io.Reader) (*AdresseIter, error) { + r := csv.NewReader(in) + r.Comma = ',' + + // Read first line as headers + name, err := r.Read() + if err != nil { + return nil, err + } + + ret := &AdresseIter{a: make(chan Adresse, 100)} + if err != nil { + return nil, err + } + go func() { + defer close(ret.a) + v := make(map[string]string, len(name)) + for { + records, err := r.Read() + if err != nil { + ret.err = err + return + } + // Map to indexes, so we don't rely on index numbers, but on column names. + for j := range records { + v[name[j]] = records[j] + } + // PROCESS: id,status,oprettet,ændret,vejkode,vejnavn,husnr,etage,dør,supplerendebynavn + a := Adresse{} + a.ID = v["id"] + a.Status, err = strconv.Atoi(v["status"]) + if err != nil { + ret.err = err + return + } + + // Example 2000-02-16T21:58:33.000 + o, err := ParseTime(v["oprettet"]) + if err != nil { + ret.err = err + return + } + a.Historik.Oprettet = *o + + o, err = ParseTime(v["ændret"]) + if err != nil { + ret.err = err + return + } + a.Historik.Ændret = *o + + a.Adgangsadresse.Vejstykke.Kode = v["vejkode"] + a.Adgangsadresse.Vejstykke.Navn = v["vejnavn"] + a.Adgangsadresse.Husnr = v["husnr"] + a.Etage = v["etage"] + a.Adgangsadresse.SupplerendeBynavn = v["supplerendebynavn"] + + // PROCESS: postnr,postnrnavn,kommunekode,kommunenavn,ejerlavkode,ejerlavnavn,matrikelnr,esrejendomsnr,etrs89koordinat_øst,etrs89koordinat_nord,wgs84koordinat_bredde,wgs84koordinat_længde, + a.Adgangsadresse.Postnummer.Nr = v["postnr"] + a.Adgangsadresse.Postnummer.Navn = v["postnrnavn"] + a.Adgangsadresse.Kommune.Kode = v["kommunekode"] + a.Adgangsadresse.Kommune.Navn = v["kommunenavn"] + a.Adgangsadresse.Ejerlav.Kode, _ = strconv.Atoi(v["ejerlavkode"]) + a.Adgangsadresse.Ejerlav.Navn = v["ejerlavnavn"] + a.Adgangsadresse.Matrikelnr = v["matrikelnr"] + a.Adgangsadresse.EsrEjendomsNr = v["esrejendomsnr"] + // ???? + // x,_ = strconv.ParseFloat("etrs89koordinat_øst") + // x,_ = strconv.ParseFloat("etrs89koordinat_nord") + a.Adgangsadresse.Adgangspunkt.Koordinater = make([]float64, 2) + a.Adgangsadresse.Adgangspunkt.Koordinater[0], _ = strconv.ParseFloat(v["wgs84koordinat_bredde"], 64) + a.Adgangsadresse.Adgangspunkt.Koordinater[1], _ = strconv.ParseFloat(v["wgs84koordinat_længde"], 64) + + // PROCESS: nøjagtighed,kilde,tekniskstandard,tekstretning,ddkn_m100,ddkn_km1,ddkn_km10,adressepunktændringsdato,adgangsadresseid,adgangsadresse_status + a.Adgangsadresse.Adgangspunkt.Nøjagtighed = v["nøjagtighed"] + a.Adgangsadresse.Adgangspunkt.Kilde, _ = strconv.Atoi(v["nøjagtighed"]) + a.Adgangsadresse.Adgangspunkt.Tekniskstandard = v["tekniskstandard"] + a.Adgangsadresse.Adgangspunkt.Tekstretning, _ = strconv.ParseFloat(v["tekstretning"], 64) + a.Adgangsadresse.DDKN.M100 = v["ddkn_m100"] + a.Adgangsadresse.DDKN.Km1 = v["ddkn_km1"] + a.Adgangsadresse.DDKN.Km10 = v["ddkn_km10"] + o, err = ParseTime(v["adressepunktændringsdato"]) + if err != nil { + ret.err = err + return + } + a.Adgangsadresse.Adgangspunkt.Ændret = *o + a.Adgangsadresse.ID = v["adgangsadresseid"] + a.Adgangsadresse.Status, _ = strconv.Atoi(v["adgangsadresse_status"]) + + // PROCESS: adgangsadresse_oprettet,adgangsadresse_ændret,kvhx,regionskode,regionsnavn,sognekode,sognenavn,politikredskode,politikredsnavn,retskredskode,retskredsnavn + o, err = ParseTime(v["adgangsadresse_oprettet"]) + if err != nil { + ret.err = err + return + } + a.Adgangsadresse.Historik.Oprettet = *o + o, err = ParseTime(v["adgangsadresse_ændret"]) + if err != nil { + ret.err = err + return + } + a.Adgangsadresse.Historik.Ændret = *o + a.Kvhx = v["kvhx"] + a.Adgangsadresse.Kvh = string([]byte(a.Kvhx)[:12]) + a.Adgangsadresse.Region.Kode = v["regionskode"] + a.Adgangsadresse.Region.Navn = v["regionsnavn"] + a.Adgangsadresse.Sogn.Kode = v["sognekode"] + a.Adgangsadresse.Sogn.Navn = v["sognenavn"] + a.Adgangsadresse.Politikreds.Kode = v["politikredskode"] + a.Adgangsadresse.Politikreds.Navn = v["politikredsnavn"] + a.Adgangsadresse.Retskreds.Kode = v["retskredskode"] + a.Adgangsadresse.Retskreds.Navn = v["retskredsnavn"] + + // opstillingskredskode,opstillingskredsnavn,zone + a.Adgangsadresse.Opstillingskreds.Kode = v["opstillingskredskode"] + a.Adgangsadresse.Opstillingskreds.Navn = v["opstillingskredsnavn"] + a.Adgangsadresse.Zone = v["zone"] + ret.a <- a + } + }() + return ret, nil +} + +// ImportAdresserJSON will import "adresser" from a JSON input, supplied to the reader. +// An iterator will be returned that return all addresses. +func ImportAdresserJSON(in io.Reader) (*AdresseIter, error) { + reader := bufio.NewReader(in) + + //Skip until after '[' + _, err := reader.ReadBytes('[') + if err != nil { + return nil, err + } + // Start decoder + ret := &AdresseIter{a: make(chan Adresse, 100)} + go func() { + defer close(ret.a) + var h codec.JsonHandle + h.ErrorIfNoField = true + for { + var dec *codec.Decoder = codec.NewDecoder(reader, &h) + a := Adresse{} + if err := dec.Decode(&a); err != nil { + ret.err = err + return + } + ret.a <- a + + // Skip comma + if b, err := readByteSkippingSpace(reader); err != nil { + ret.err = err + return + } else { + switch b { + case ',': + continue + case ']': + ret.err = io.EOF + return + default: + panic("Invalid character in JSON data: " + string([]byte{b})) + } + } + + } + }() + return ret, nil +} diff --git a/import-postnumre.go b/import-postnumre.go new file mode 100644 index 0000000..e618fd2 --- /dev/null +++ b/import-postnumre.go @@ -0,0 +1,69 @@ +package dawa + +import ( + "bufio" + "github.com/ugorji/go/codec" + "io" +) + +// PostnummerIter is an Iterator that enable you to get individual entries. +type PostnummerIter struct { + a chan Postnummer + err error +} + +// Next will return addresses. +// It will return an error if that has been encountered. +// When there are not more entries nil, io.EOF will be returned. +func (a *PostnummerIter) Next() (*Postnummer, error) { + v, ok := <-a.a + if ok { + return &v, nil + } + return nil, a.err +} + +// ImportPostnummerrJSON will import "adresser" from a JSON input, supplied to the reader. +// An iterator will be returned that return all addresses. +func ImportPostnumreJSON(in io.Reader) (*PostnummerIter, error) { + reader := bufio.NewReader(in) + // Skip until after '[' + _, err := reader.ReadBytes('[') + if err != nil { + return nil, err + } + // Start decoder + ret := &PostnummerIter{a: make(chan Postnummer, 100)} + go func() { + defer close(ret.a) + var h codec.JsonHandle + h.ErrorIfNoField = true + for { + var dec *codec.Decoder = codec.NewDecoder(reader, &h) + a := Postnummer{} + if err := dec.Decode(&a); err != nil { + ret.err = err + return + } + ret.a <- a + + // Skip comma + if b, err := readByteSkippingSpace(reader); err != nil { + ret.err = err + return + } else { + switch b { + case ',': + continue + case ']': + ret.err = io.EOF + return + default: + panic("Invalid character in JSON data: " + string([]byte{b})) + } + } + + } + }() + return ret, nil +} diff --git a/import-vejstykker.go b/import-vejstykker.go new file mode 100644 index 0000000..3cb7b57 --- /dev/null +++ b/import-vejstykker.go @@ -0,0 +1,69 @@ +package dawa + +import ( + "bufio" + "github.com/ugorji/go/codec" + "io" +) + +// VejstykkeIter is an Iterator that enable you to get individual entries. +type VejstykkeIter struct { + a chan Vejstykke + err error +} + +// Next will return addresses. +// It will return an error if that has been encountered. +// When there are not more entries nil, io.EOF will be returned. +func (a *VejstykkeIter) Next() (*Vejstykke, error) { + v, ok := <-a.a + if ok { + return &v, nil + } + return nil, a.err +} + +// ImportVejstykkerJSON will import "adresser" from a JSON input, supplied to the reader. +// An iterator will be returned that return all addresses. +func ImportVejstykkerJSON(in io.Reader) (*VejstykkeIter, error) { + reader := bufio.NewReader(in) + // Skip until after '[' + _, err := reader.ReadBytes('[') + if err != nil { + return nil, err + } + // Start decoder + ret := &VejstykkeIter{a: make(chan Vejstykke, 100)} + go func() { + defer close(ret.a) + var h codec.JsonHandle + h.ErrorIfNoField = true + for { + var dec *codec.Decoder = codec.NewDecoder(reader, &h) + a := Vejstykke{} + if err := dec.Decode(&a); err != nil { + ret.err = err + return + } + ret.a <- a + + // Skip comma + if b, err := readByteSkippingSpace(reader); err != nil { + ret.err = err + return + } else { + switch b { + case ',': + continue + case ']': + ret.err = io.EOF + return + default: + panic("Invalid character in JSON data: " + string([]byte{b})) + } + } + + } + }() + return ret, nil +} diff --git a/postnummer.go b/postnummer.go new file mode 100644 index 0000000..7d65702 --- /dev/null +++ b/postnummer.go @@ -0,0 +1,10 @@ +package dawa + +type Postnummer struct { + Href string `json:"href"` // Postnummerets unikke URL. + Kommuner []Kommune `json:"kommuner"` // De kommuner hvis areal overlapper postnumeret areal. + Navn string `json:"navn"` // Det navn der er knyttet til postnummeret, typisk byens eller bydelens navn. Repræsenteret ved indtil 20 tegn. Eksempel: ”København NV”. + Nr string `json:"nr"` // Unik identifikation af det postnummeret. Postnumre fastsættes af Post Danmark. Repræsenteret ved fire cifre. Eksempel: ”2400” for ”København NV”. + // Never set to anything but null + Stormodtageradresser interface{} `json:"stormodtageradresser"` // Hvis postnummeret er et stormodtagerpostnummer rummer feltet adresserne på stormodtageren. +} diff --git a/values.generated.go b/values.generated.go new file mode 100644 index 0000000..d3f8173 --- /dev/null +++ b/values.generated.go @@ -0,0 +1,4938 @@ +// ************************************************************ +// DO NOT EDIT. +// THIS FILE IS AUTO-GENERATED BY codecgen. +// ************************************************************ + +package dawa + +import ( + "errors" + "fmt" + codec1978 "github.com/ugorji/go/codec" + "reflect" + "runtime" +) + +const ( + codecSelferC_UTF81474 = 1 + codecSelferC_RAW1474 = 0 + codecSelverValueTypeArray1474 = 10 + codecSelverValueTypeMap1474 = 9 +) + +var ( + codecSelferBitsize1474 = uint8(reflect.TypeOf(uint(0)).Bits()) + codecSelferOnlyMapOrArrayEncodeToStructErr1474 = errors.New(`only encoded map or array can be decoded into a struct`) +) + +type codecSelfer1474 struct{} + +func init() { + if codec1978.GenVersion != 1 { + _, file, _, _ := runtime.Caller(0) + err := fmt.Errorf("codecgen version mismatch: current: %v, need %v. Re-generate file: %v", + 1, codec1978.GenVersion, file) + panic(err) + } + if false { // reference the types, but skip this branch at build/run time + } +} + +func (x *Postnummer) CodecEncodeSelf(e *codec1978.Encoder) { + var h codecSelfer1474 + z, r := codec1978.GenHelperEncoder(e) + _, _, _ = h, z, r + if x == nil { + r.EncodeNil() + } else { + yysep1 := !z.EncBinary() + const yyr1 bool = false + var yyq1 [5]bool + if yyr1 || z.EncBasicHandle().StructToArray { + r.EncodeArrayStart(5) + } else { + var yynn1 int = 5 + for _, b := range yyq1 { + if b { + yynn1++ + } + } + r.EncodeMapStart(yynn1) + } + if yyr1 || z.EncBasicHandle().StructToArray { + r.EncodeString(codecSelferC_UTF81474, string(x.Href)) + } else { + r.EncodeString(codecSelferC_UTF81474, string("Href")) + if yysep1 { + r.EncodeMapKVSeparator() + } + r.EncodeString(codecSelferC_UTF81474, string(x.Href)) + } + if yyr1 || z.EncBasicHandle().StructToArray { + if yysep1 { + r.EncodeArrayEntrySeparator() + } + if x.Kommuner == nil { + r.EncodeNil() + } else { + h.encSliceKommune([]Kommune(x.Kommuner), e) + } + } else { + if yysep1 { + r.EncodeMapEntrySeparator() + } + r.EncodeString(codecSelferC_UTF81474, string("Kommuner")) + if yysep1 { + r.EncodeMapKVSeparator() + } + if x.Kommuner == nil { + r.EncodeNil() + } else { + h.encSliceKommune([]Kommune(x.Kommuner), e) + } + } + if yyr1 || z.EncBasicHandle().StructToArray { + if yysep1 { + r.EncodeArrayEntrySeparator() + } + r.EncodeString(codecSelferC_UTF81474, string(x.Navn)) + } else { + if yysep1 { + r.EncodeMapEntrySeparator() + } + r.EncodeString(codecSelferC_UTF81474, string("Navn")) + if yysep1 { + r.EncodeMapKVSeparator() + } + r.EncodeString(codecSelferC_UTF81474, string(x.Navn)) + } + if yyr1 || z.EncBasicHandle().StructToArray { + if yysep1 { + r.EncodeArrayEntrySeparator() + } + r.EncodeString(codecSelferC_UTF81474, string(x.Nr)) + } else { + if yysep1 { + r.EncodeMapEntrySeparator() + } + r.EncodeString(codecSelferC_UTF81474, string("Nr")) + if yysep1 { + r.EncodeMapKVSeparator() + } + r.EncodeString(codecSelferC_UTF81474, string(x.Nr)) + } + if yyr1 || z.EncBasicHandle().StructToArray { + if yysep1 { + r.EncodeArrayEntrySeparator() + } + if x.Stormodtageradresser == nil { + r.EncodeNil() + } else { + z.EncFallback(x.Stormodtageradresser) + } + } else { + if yysep1 { + r.EncodeMapEntrySeparator() + } + r.EncodeString(codecSelferC_UTF81474, string("Stormodtageradresser")) + if yysep1 { + r.EncodeMapKVSeparator() + } + if x.Stormodtageradresser == nil { + r.EncodeNil() + } else { + z.EncFallback(x.Stormodtageradresser) + } + } + if yysep1 { + if yyr1 || z.EncBasicHandle().StructToArray { + r.EncodeArrayEnd() + } else { + r.EncodeMapEnd() + } + } + } +} + +func (x *Postnummer) CodecDecodeSelf(d *codec1978.Decoder) { + var h codecSelfer1474 + z, r := codec1978.GenHelperDecoder(d) + _, _, _ = h, z, r + if r.IsContainerType(codecSelverValueTypeMap1474) { + yyl7 := r.ReadMapStart() + if yyl7 == 0 { + r.ReadMapEnd() + } else { + x.codecDecodeSelfFromMap(yyl7, d) + } + } else if r.IsContainerType(codecSelverValueTypeArray1474) { + yyl7 := r.ReadArrayStart() + if yyl7 == 0 { + r.ReadArrayEnd() + } else { + x.codecDecodeSelfFromArray(yyl7, d) + } + } else { + panic(codecSelferOnlyMapOrArrayEncodeToStructErr1474) + } +} + +func (x *Postnummer) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) { + var h codecSelfer1474 + z, r := codec1978.GenHelperDecoder(d) + _, _, _ = h, z, r + var yys8Slc = z.DecScratchBuffer() // default slice to decode into + _ = yys8Slc + var yyhl8 bool = l >= 0 + for yyj8 := 0; ; yyj8++ { + if yyhl8 { + if yyj8 >= l { + break + } + } else { + if r.CheckBreak() { + break + } + if yyj8 > 0 { + r.ReadMapEntrySeparator() + } + } + yys8Slc = r.DecodeBytes(yys8Slc, true, true) + yys8 := string(yys8Slc) + if !yyhl8 { + r.ReadMapKVSeparator() + } + switch yys8 { + case "href": + if r.TryDecodeAsNil() { + x.Href = "" + } else { + x.Href = r.DecodeString() + } + case "kommuner": + if r.TryDecodeAsNil() { + x.Kommuner = nil + } else { + yyv10 := &x.Kommuner + h.decSliceKommune((*[]Kommune)(yyv10), d) + } + case "navn": + if r.TryDecodeAsNil() { + x.Navn = "" + } else { + x.Navn = r.DecodeString() + } + case "nr": + if r.TryDecodeAsNil() { + x.Nr = "" + } else { + x.Nr = r.DecodeString() + } + case "stormodtageradresser": + if r.TryDecodeAsNil() { + x.Stormodtageradresser = nil + } else { + yyv13 := &x.Stormodtageradresser + z.DecFallback(yyv13, true) + } + default: + z.DecStructFieldNotFound(-1, yys8) + } // end switch yys8 + } // end for yyj8 + if !yyhl8 { + r.ReadMapEnd() + } +} + +func (x *Postnummer) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { + var h codecSelfer1474 + z, r := codec1978.GenHelperDecoder(d) + _, _, _ = h, z, r + var yyj14 int + var yyb14 bool + var yyhl14 bool = l >= 0 + yyj14++ + if yyhl14 { + yyb14 = yyj14 > l + } else { + yyb14 = r.CheckBreak() + } + if yyb14 { + r.ReadArrayEnd() + return + } + if r.TryDecodeAsNil() { + x.Href = "" + } else { + x.Href = r.DecodeString() + } + yyj14++ + if yyhl14 { + yyb14 = yyj14 > l + } else { + yyb14 = r.CheckBreak() + } + if yyb14 { + r.ReadArrayEnd() + return + } + r.ReadArrayEntrySeparator() + if r.TryDecodeAsNil() { + x.Kommuner = nil + } else { + yyv16 := &x.Kommuner + h.decSliceKommune((*[]Kommune)(yyv16), d) + } + yyj14++ + if yyhl14 { + yyb14 = yyj14 > l + } else { + yyb14 = r.CheckBreak() + } + if yyb14 { + r.ReadArrayEnd() + return + } + r.ReadArrayEntrySeparator() + if r.TryDecodeAsNil() { + x.Navn = "" + } else { + x.Navn = r.DecodeString() + } + yyj14++ + if yyhl14 { + yyb14 = yyj14 > l + } else { + yyb14 = r.CheckBreak() + } + if yyb14 { + r.ReadArrayEnd() + return + } + r.ReadArrayEntrySeparator() + if r.TryDecodeAsNil() { + x.Nr = "" + } else { + x.Nr = r.DecodeString() + } + yyj14++ + if yyhl14 { + yyb14 = yyj14 > l + } else { + yyb14 = r.CheckBreak() + } + if yyb14 { + r.ReadArrayEnd() + return + } + r.ReadArrayEntrySeparator() + if r.TryDecodeAsNil() { + x.Stormodtageradresser = nil + } else { + yyv19 := &x.Stormodtageradresser + z.DecFallback(yyv19, true) + } + for { + yyj14++ + if yyhl14 { + yyb14 = yyj14 > l + } else { + yyb14 = r.CheckBreak() + } + if yyb14 { + break + } + if yyj14 > 1 { + r.ReadArrayEntrySeparator() + } + z.DecStructFieldNotFound(yyj14-1, "") + } + r.ReadArrayEnd() +} + +func (x *Adresse) CodecEncodeSelf(e *codec1978.Encoder) { + var h codecSelfer1474 + z, r := codec1978.GenHelperEncoder(e) + _, _, _ = h, z, r + if x == nil { + r.EncodeNil() + } else { + yysep20 := !z.EncBinary() + const yyr20 bool = false + var yyq20 [9]bool + if yyr20 || z.EncBasicHandle().StructToArray { + r.EncodeArrayStart(9) + } else { + var yynn20 int = 9 + for _, b := range yyq20 { + if b { + yynn20++ + } + } + r.EncodeMapStart(yynn20) + } + if yyr20 || z.EncBasicHandle().StructToArray { + x.Adgangsadresse.CodecEncodeSelf(e) + } else { + r.EncodeString(codecSelferC_UTF81474, string("Adgangsadresse")) + if yysep20 { + r.EncodeMapKVSeparator() + } + x.Adgangsadresse.CodecEncodeSelf(e) + } + if yyr20 || z.EncBasicHandle().StructToArray { + if yysep20 { + r.EncodeArrayEntrySeparator() + } + r.EncodeString(codecSelferC_UTF81474, string(x.Adressebetegnelse)) + } else { + if yysep20 { + r.EncodeMapEntrySeparator() + } + r.EncodeString(codecSelferC_UTF81474, string("Adressebetegnelse")) + if yysep20 { + r.EncodeMapKVSeparator() + } + r.EncodeString(codecSelferC_UTF81474, string(x.Adressebetegnelse)) + } + if yyr20 || z.EncBasicHandle().StructToArray { + if yysep20 { + r.EncodeArrayEntrySeparator() + } + r.EncodeString(codecSelferC_UTF81474, string(x.Dør)) + } else { + if yysep20 { + r.EncodeMapEntrySeparator() + } + r.EncodeString(codecSelferC_UTF81474, string("Dør")) + if yysep20 { + r.EncodeMapKVSeparator() + } + r.EncodeString(codecSelferC_UTF81474, string(x.Dør)) + } + if yyr20 || z.EncBasicHandle().StructToArray { + if yysep20 { + r.EncodeArrayEntrySeparator() + } + r.EncodeString(codecSelferC_UTF81474, string(x.Etage)) + } else { + if yysep20 { + r.EncodeMapEntrySeparator() + } + r.EncodeString(codecSelferC_UTF81474, string("Etage")) + if yysep20 { + r.EncodeMapKVSeparator() + } + r.EncodeString(codecSelferC_UTF81474, string(x.Etage)) + } + if yyr20 || z.EncBasicHandle().StructToArray { + if yysep20 { + r.EncodeArrayEntrySeparator() + } + x.Historik.CodecEncodeSelf(e) + } else { + if yysep20 { + r.EncodeMapEntrySeparator() + } + r.EncodeString(codecSelferC_UTF81474, string("Historik")) + if yysep20 { + r.EncodeMapKVSeparator() + } + x.Historik.CodecEncodeSelf(e) + } + if yyr20 || z.EncBasicHandle().StructToArray { + if yysep20 { + r.EncodeArrayEntrySeparator() + } + r.EncodeString(codecSelferC_UTF81474, string(x.Href)) + } else { + if yysep20 { + r.EncodeMapEntrySeparator() + } + r.EncodeString(codecSelferC_UTF81474, string("Href")) + if yysep20 { + r.EncodeMapKVSeparator() + } + r.EncodeString(codecSelferC_UTF81474, string(x.Href)) + } + if yyr20 || z.EncBasicHandle().StructToArray { + if yysep20 { + r.EncodeArrayEntrySeparator() + } + r.EncodeString(codecSelferC_UTF81474, string(x.ID)) + } else { + if yysep20 { + r.EncodeMapEntrySeparator() + } + r.EncodeString(codecSelferC_UTF81474, string("ID")) + if yysep20 { + r.EncodeMapKVSeparator() + } + r.EncodeString(codecSelferC_UTF81474, string(x.ID)) + } + if yyr20 || z.EncBasicHandle().StructToArray { + if yysep20 { + r.EncodeArrayEntrySeparator() + } + r.EncodeString(codecSelferC_UTF81474, string(x.Kvhx)) + } else { + if yysep20 { + r.EncodeMapEntrySeparator() + } + r.EncodeString(codecSelferC_UTF81474, string("Kvhx")) + if yysep20 { + r.EncodeMapKVSeparator() + } + r.EncodeString(codecSelferC_UTF81474, string(x.Kvhx)) + } + if yyr20 || z.EncBasicHandle().StructToArray { + if yysep20 { + r.EncodeArrayEntrySeparator() + } + r.EncodeInt(int64(x.Status)) + } else { + if yysep20 { + r.EncodeMapEntrySeparator() + } + r.EncodeString(codecSelferC_UTF81474, string("Status")) + if yysep20 { + r.EncodeMapKVSeparator() + } + r.EncodeInt(int64(x.Status)) + } + if yysep20 { + if yyr20 || z.EncBasicHandle().StructToArray { + r.EncodeArrayEnd() + } else { + r.EncodeMapEnd() + } + } + } +} + +func (x *Adresse) CodecDecodeSelf(d *codec1978.Decoder) { + var h codecSelfer1474 + z, r := codec1978.GenHelperDecoder(d) + _, _, _ = h, z, r + if r.IsContainerType(codecSelverValueTypeMap1474) { + yyl30 := r.ReadMapStart() + if yyl30 == 0 { + r.ReadMapEnd() + } else { + x.codecDecodeSelfFromMap(yyl30, d) + } + } else if r.IsContainerType(codecSelverValueTypeArray1474) { + yyl30 := r.ReadArrayStart() + if yyl30 == 0 { + r.ReadArrayEnd() + } else { + x.codecDecodeSelfFromArray(yyl30, d) + } + } else { + panic(codecSelferOnlyMapOrArrayEncodeToStructErr1474) + } +} + +func (x *Adresse) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) { + var h codecSelfer1474 + z, r := codec1978.GenHelperDecoder(d) + _, _, _ = h, z, r + var yys31Slc = z.DecScratchBuffer() // default slice to decode into + _ = yys31Slc + var yyhl31 bool = l >= 0 + for yyj31 := 0; ; yyj31++ { + if yyhl31 { + if yyj31 >= l { + break + } + } else { + if r.CheckBreak() { + break + } + if yyj31 > 0 { + r.ReadMapEntrySeparator() + } + } + yys31Slc = r.DecodeBytes(yys31Slc, true, true) + yys31 := string(yys31Slc) + if !yyhl31 { + r.ReadMapKVSeparator() + } + switch yys31 { + case "adgangsadresse": + if r.TryDecodeAsNil() { + x.Adgangsadresse = AdgangsAdresse{} + } else { + yyv32 := &x.Adgangsadresse + yyv32.CodecDecodeSelf(d) + } + case "adressebetegnelse": + if r.TryDecodeAsNil() { + x.Adressebetegnelse = "" + } else { + x.Adressebetegnelse = r.DecodeString() + } + case "dør": + if r.TryDecodeAsNil() { + x.Dør = "" + } else { + x.Dør = r.DecodeString() + } + case "etage": + if r.TryDecodeAsNil() { + x.Etage = "" + } else { + x.Etage = r.DecodeString() + } + case "historik": + if r.TryDecodeAsNil() { + x.Historik = Historik{} + } else { + yyv36 := &x.Historik + yyv36.CodecDecodeSelf(d) + } + case "href": + if r.TryDecodeAsNil() { + x.Href = "" + } else { + x.Href = r.DecodeString() + } + case "id": + if r.TryDecodeAsNil() { + x.ID = "" + } else { + x.ID = r.DecodeString() + } + case "kvhx": + if r.TryDecodeAsNil() { + x.Kvhx = "" + } else { + x.Kvhx = r.DecodeString() + } + case "status": + if r.TryDecodeAsNil() { + x.Status = 0 + } else { + x.Status = int(r.DecodeInt(codecSelferBitsize1474)) + } + default: + z.DecStructFieldNotFound(-1, yys31) + } // end switch yys31 + } // end for yyj31 + if !yyhl31 { + r.ReadMapEnd() + } +} + +func (x *Adresse) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { + var h codecSelfer1474 + z, r := codec1978.GenHelperDecoder(d) + _, _, _ = h, z, r + var yyj41 int + var yyb41 bool + var yyhl41 bool = l >= 0 + yyj41++ + if yyhl41 { + yyb41 = yyj41 > l + } else { + yyb41 = r.CheckBreak() + } + if yyb41 { + r.ReadArrayEnd() + return + } + if r.TryDecodeAsNil() { + x.Adgangsadresse = AdgangsAdresse{} + } else { + yyv42 := &x.Adgangsadresse + yyv42.CodecDecodeSelf(d) + } + yyj41++ + if yyhl41 { + yyb41 = yyj41 > l + } else { + yyb41 = r.CheckBreak() + } + if yyb41 { + r.ReadArrayEnd() + return + } + r.ReadArrayEntrySeparator() + if r.TryDecodeAsNil() { + x.Adressebetegnelse = "" + } else { + x.Adressebetegnelse = r.DecodeString() + } + yyj41++ + if yyhl41 { + yyb41 = yyj41 > l + } else { + yyb41 = r.CheckBreak() + } + if yyb41 { + r.ReadArrayEnd() + return + } + r.ReadArrayEntrySeparator() + if r.TryDecodeAsNil() { + x.Dør = "" + } else { + x.Dør = r.DecodeString() + } + yyj41++ + if yyhl41 { + yyb41 = yyj41 > l + } else { + yyb41 = r.CheckBreak() + } + if yyb41 { + r.ReadArrayEnd() + return + } + r.ReadArrayEntrySeparator() + if r.TryDecodeAsNil() { + x.Etage = "" + } else { + x.Etage = r.DecodeString() + } + yyj41++ + if yyhl41 { + yyb41 = yyj41 > l + } else { + yyb41 = r.CheckBreak() + } + if yyb41 { + r.ReadArrayEnd() + return + } + r.ReadArrayEntrySeparator() + if r.TryDecodeAsNil() { + x.Historik = Historik{} + } else { + yyv46 := &x.Historik + yyv46.CodecDecodeSelf(d) + } + yyj41++ + if yyhl41 { + yyb41 = yyj41 > l + } else { + yyb41 = r.CheckBreak() + } + if yyb41 { + r.ReadArrayEnd() + return + } + r.ReadArrayEntrySeparator() + if r.TryDecodeAsNil() { + x.Href = "" + } else { + x.Href = r.DecodeString() + } + yyj41++ + if yyhl41 { + yyb41 = yyj41 > l + } else { + yyb41 = r.CheckBreak() + } + if yyb41 { + r.ReadArrayEnd() + return + } + r.ReadArrayEntrySeparator() + if r.TryDecodeAsNil() { + x.ID = "" + } else { + x.ID = r.DecodeString() + } + yyj41++ + if yyhl41 { + yyb41 = yyj41 > l + } else { + yyb41 = r.CheckBreak() + } + if yyb41 { + r.ReadArrayEnd() + return + } + r.ReadArrayEntrySeparator() + if r.TryDecodeAsNil() { + x.Kvhx = "" + } else { + x.Kvhx = r.DecodeString() + } + yyj41++ + if yyhl41 { + yyb41 = yyj41 > l + } else { + yyb41 = r.CheckBreak() + } + if yyb41 { + r.ReadArrayEnd() + return + } + r.ReadArrayEntrySeparator() + if r.TryDecodeAsNil() { + x.Status = 0 + } else { + x.Status = int(r.DecodeInt(codecSelferBitsize1474)) + } + for { + yyj41++ + if yyhl41 { + yyb41 = yyj41 > l + } else { + yyb41 = r.CheckBreak() + } + if yyb41 { + break + } + if yyj41 > 1 { + r.ReadArrayEntrySeparator() + } + z.DecStructFieldNotFound(yyj41-1, "") + } + r.ReadArrayEnd() +} + +func (x *AdgangsAdresse) CodecEncodeSelf(e *codec1978.Encoder) { + var h codecSelfer1474 + z, r := codec1978.GenHelperEncoder(e) + _, _, _ = h, z, r + if x == nil { + r.EncodeNil() + } else { + yysep51 := !z.EncBinary() + const yyr51 bool = false + var yyq51 [21]bool + if yyr51 || z.EncBasicHandle().StructToArray { + r.EncodeArrayStart(21) + } else { + var yynn51 int = 21 + for _, b := range yyq51 { + if b { + yynn51++ + } + } + r.EncodeMapStart(yynn51) + } + if yyr51 || z.EncBasicHandle().StructToArray { + x.DDKN.CodecEncodeSelf(e) + } else { + r.EncodeString(codecSelferC_UTF81474, string("DDKN")) + if yysep51 { + r.EncodeMapKVSeparator() + } + x.DDKN.CodecEncodeSelf(e) + } + if yyr51 || z.EncBasicHandle().StructToArray { + if yysep51 { + r.EncodeArrayEntrySeparator() + } + x.Adgangspunkt.CodecEncodeSelf(e) + } else { + if yysep51 { + r.EncodeMapEntrySeparator() + } + r.EncodeString(codecSelferC_UTF81474, string("Adgangspunkt")) + if yysep51 { + r.EncodeMapKVSeparator() + } + x.Adgangspunkt.CodecEncodeSelf(e) + } + if yyr51 || z.EncBasicHandle().StructToArray { + if yysep51 { + r.EncodeArrayEntrySeparator() + } + x.Ejerlav.CodecEncodeSelf(e) + } else { + if yysep51 { + r.EncodeMapEntrySeparator() + } + r.EncodeString(codecSelferC_UTF81474, string("Ejerlav")) + if yysep51 { + r.EncodeMapKVSeparator() + } + x.Ejerlav.CodecEncodeSelf(e) + } + if yyr51 || z.EncBasicHandle().StructToArray { + if yysep51 { + r.EncodeArrayEntrySeparator() + } + r.EncodeString(codecSelferC_UTF81474, string(x.EsrEjendomsNr)) + } else { + if yysep51 { + r.EncodeMapEntrySeparator() + } + r.EncodeString(codecSelferC_UTF81474, string("EsrEjendomsNr")) + if yysep51 { + r.EncodeMapKVSeparator() + } + r.EncodeString(codecSelferC_UTF81474, string(x.EsrEjendomsNr)) + } + if yyr51 || z.EncBasicHandle().StructToArray { + if yysep51 { + r.EncodeArrayEntrySeparator() + } + x.Historik.CodecEncodeSelf(e) + } else { + if yysep51 { + r.EncodeMapEntrySeparator() + } + r.EncodeString(codecSelferC_UTF81474, string("Historik")) + if yysep51 { + r.EncodeMapKVSeparator() + } + x.Historik.CodecEncodeSelf(e) + } + if yyr51 || z.EncBasicHandle().StructToArray { + if yysep51 { + r.EncodeArrayEntrySeparator() + } + r.EncodeString(codecSelferC_UTF81474, string(x.Href)) + } else { + if yysep51 { + r.EncodeMapEntrySeparator() + } + r.EncodeString(codecSelferC_UTF81474, string("Href")) + if yysep51 { + r.EncodeMapKVSeparator() + } + r.EncodeString(codecSelferC_UTF81474, string(x.Href)) + } + if yyr51 || z.EncBasicHandle().StructToArray { + if yysep51 { + r.EncodeArrayEntrySeparator() + } + r.EncodeString(codecSelferC_UTF81474, string(x.Husnr)) + } else { + if yysep51 { + r.EncodeMapEntrySeparator() + } + r.EncodeString(codecSelferC_UTF81474, string("Husnr")) + if yysep51 { + r.EncodeMapKVSeparator() + } + r.EncodeString(codecSelferC_UTF81474, string(x.Husnr)) + } + if yyr51 || z.EncBasicHandle().StructToArray { + if yysep51 { + r.EncodeArrayEntrySeparator() + } + r.EncodeString(codecSelferC_UTF81474, string(x.ID)) + } else { + if yysep51 { + r.EncodeMapEntrySeparator() + } + r.EncodeString(codecSelferC_UTF81474, string("ID")) + if yysep51 { + r.EncodeMapKVSeparator() + } + r.EncodeString(codecSelferC_UTF81474, string(x.ID)) + } + if yyr51 || z.EncBasicHandle().StructToArray { + if yysep51 { + r.EncodeArrayEntrySeparator() + } + x.Kommune.CodecEncodeSelf(e) + } else { + if yysep51 { + r.EncodeMapEntrySeparator() + } + r.EncodeString(codecSelferC_UTF81474, string("Kommune")) + if yysep51 { + r.EncodeMapKVSeparator() + } + x.Kommune.CodecEncodeSelf(e) + } + if yyr51 || z.EncBasicHandle().StructToArray { + if yysep51 { + r.EncodeArrayEntrySeparator() + } + r.EncodeString(codecSelferC_UTF81474, string(x.Kvh)) + } else { + if yysep51 { + r.EncodeMapEntrySeparator() + } + r.EncodeString(codecSelferC_UTF81474, string("Kvh")) + if yysep51 { + r.EncodeMapKVSeparator() + } + r.EncodeString(codecSelferC_UTF81474, string(x.Kvh)) + } + if yyr51 || z.EncBasicHandle().StructToArray { + if yysep51 { + r.EncodeArrayEntrySeparator() + } + r.EncodeString(codecSelferC_UTF81474, string(x.Matrikelnr)) + } else { + if yysep51 { + r.EncodeMapEntrySeparator() + } + r.EncodeString(codecSelferC_UTF81474, string("Matrikelnr")) + if yysep51 { + r.EncodeMapKVSeparator() + } + r.EncodeString(codecSelferC_UTF81474, string(x.Matrikelnr)) + } + if yyr51 || z.EncBasicHandle().StructToArray { + if yysep51 { + r.EncodeArrayEntrySeparator() + } + x.Opstillingskreds.CodecEncodeSelf(e) + } else { + if yysep51 { + r.EncodeMapEntrySeparator() + } + r.EncodeString(codecSelferC_UTF81474, string("Opstillingskreds")) + if yysep51 { + r.EncodeMapKVSeparator() + } + x.Opstillingskreds.CodecEncodeSelf(e) + } + if yyr51 || z.EncBasicHandle().StructToArray { + if yysep51 { + r.EncodeArrayEntrySeparator() + } + x.Politikreds.CodecEncodeSelf(e) + } else { + if yysep51 { + r.EncodeMapEntrySeparator() + } + r.EncodeString(codecSelferC_UTF81474, string("Politikreds")) + if yysep51 { + r.EncodeMapKVSeparator() + } + x.Politikreds.CodecEncodeSelf(e) + } + if yyr51 || z.EncBasicHandle().StructToArray { + if yysep51 { + r.EncodeArrayEntrySeparator() + } + x.Postnummer.CodecEncodeSelf(e) + } else { + if yysep51 { + r.EncodeMapEntrySeparator() + } + r.EncodeString(codecSelferC_UTF81474, string("Postnummer")) + if yysep51 { + r.EncodeMapKVSeparator() + } + x.Postnummer.CodecEncodeSelf(e) + } + if yyr51 || z.EncBasicHandle().StructToArray { + if yysep51 { + r.EncodeArrayEntrySeparator() + } + x.Region.CodecEncodeSelf(e) + } else { + if yysep51 { + r.EncodeMapEntrySeparator() + } + r.EncodeString(codecSelferC_UTF81474, string("Region")) + if yysep51 { + r.EncodeMapKVSeparator() + } + x.Region.CodecEncodeSelf(e) + } + if yyr51 || z.EncBasicHandle().StructToArray { + if yysep51 { + r.EncodeArrayEntrySeparator() + } + x.Retskreds.CodecEncodeSelf(e) + } else { + if yysep51 { + r.EncodeMapEntrySeparator() + } + r.EncodeString(codecSelferC_UTF81474, string("Retskreds")) + if yysep51 { + r.EncodeMapKVSeparator() + } + x.Retskreds.CodecEncodeSelf(e) + } + if yyr51 || z.EncBasicHandle().StructToArray { + if yysep51 { + r.EncodeArrayEntrySeparator() + } + x.Sogn.CodecEncodeSelf(e) + } else { + if yysep51 { + r.EncodeMapEntrySeparator() + } + r.EncodeString(codecSelferC_UTF81474, string("Sogn")) + if yysep51 { + r.EncodeMapKVSeparator() + } + x.Sogn.CodecEncodeSelf(e) + } + if yyr51 || z.EncBasicHandle().StructToArray { + if yysep51 { + r.EncodeArrayEntrySeparator() + } + r.EncodeInt(int64(x.Status)) + } else { + if yysep51 { + r.EncodeMapEntrySeparator() + } + r.EncodeString(codecSelferC_UTF81474, string("Status")) + if yysep51 { + r.EncodeMapKVSeparator() + } + r.EncodeInt(int64(x.Status)) + } + if yyr51 || z.EncBasicHandle().StructToArray { + if yysep51 { + r.EncodeArrayEntrySeparator() + } + r.EncodeString(codecSelferC_UTF81474, string(x.SupplerendeBynavn)) + } else { + if yysep51 { + r.EncodeMapEntrySeparator() + } + r.EncodeString(codecSelferC_UTF81474, string("SupplerendeBynavn")) + if yysep51 { + r.EncodeMapKVSeparator() + } + r.EncodeString(codecSelferC_UTF81474, string(x.SupplerendeBynavn)) + } + if yyr51 || z.EncBasicHandle().StructToArray { + if yysep51 { + r.EncodeArrayEntrySeparator() + } + x.Vejstykke.CodecEncodeSelf(e) + } else { + if yysep51 { + r.EncodeMapEntrySeparator() + } + r.EncodeString(codecSelferC_UTF81474, string("Vejstykke")) + if yysep51 { + r.EncodeMapKVSeparator() + } + x.Vejstykke.CodecEncodeSelf(e) + } + if yyr51 || z.EncBasicHandle().StructToArray { + if yysep51 { + r.EncodeArrayEntrySeparator() + } + r.EncodeString(codecSelferC_UTF81474, string(x.Zone)) + } else { + if yysep51 { + r.EncodeMapEntrySeparator() + } + r.EncodeString(codecSelferC_UTF81474, string("Zone")) + if yysep51 { + r.EncodeMapKVSeparator() + } + r.EncodeString(codecSelferC_UTF81474, string(x.Zone)) + } + if yysep51 { + if yyr51 || z.EncBasicHandle().StructToArray { + r.EncodeArrayEnd() + } else { + r.EncodeMapEnd() + } + } + } +} + +func (x *AdgangsAdresse) CodecDecodeSelf(d *codec1978.Decoder) { + var h codecSelfer1474 + z, r := codec1978.GenHelperDecoder(d) + _, _, _ = h, z, r + if r.IsContainerType(codecSelverValueTypeMap1474) { + yyl73 := r.ReadMapStart() + if yyl73 == 0 { + r.ReadMapEnd() + } else { + x.codecDecodeSelfFromMap(yyl73, d) + } + } else if r.IsContainerType(codecSelverValueTypeArray1474) { + yyl73 := r.ReadArrayStart() + if yyl73 == 0 { + r.ReadArrayEnd() + } else { + x.codecDecodeSelfFromArray(yyl73, d) + } + } else { + panic(codecSelferOnlyMapOrArrayEncodeToStructErr1474) + } +} + +func (x *AdgangsAdresse) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) { + var h codecSelfer1474 + z, r := codec1978.GenHelperDecoder(d) + _, _, _ = h, z, r + var yys74Slc = z.DecScratchBuffer() // default slice to decode into + _ = yys74Slc + var yyhl74 bool = l >= 0 + for yyj74 := 0; ; yyj74++ { + if yyhl74 { + if yyj74 >= l { + break + } + } else { + if r.CheckBreak() { + break + } + if yyj74 > 0 { + r.ReadMapEntrySeparator() + } + } + yys74Slc = r.DecodeBytes(yys74Slc, true, true) + yys74 := string(yys74Slc) + if !yyhl74 { + r.ReadMapKVSeparator() + } + switch yys74 { + case "DDKN": + if r.TryDecodeAsNil() { + x.DDKN = DDKN{} + } else { + yyv75 := &x.DDKN + yyv75.CodecDecodeSelf(d) + } + case "adgangspunkt": + if r.TryDecodeAsNil() { + x.Adgangspunkt = Adgangspunkt{} + } else { + yyv76 := &x.Adgangspunkt + yyv76.CodecDecodeSelf(d) + } + case "ejerlav": + if r.TryDecodeAsNil() { + x.Ejerlav = Ejerlav{} + } else { + yyv77 := &x.Ejerlav + yyv77.CodecDecodeSelf(d) + } + case "esrejendomsnr": + if r.TryDecodeAsNil() { + x.EsrEjendomsNr = "" + } else { + x.EsrEjendomsNr = r.DecodeString() + } + case "historik": + if r.TryDecodeAsNil() { + x.Historik = Historik{} + } else { + yyv79 := &x.Historik + yyv79.CodecDecodeSelf(d) + } + case "href": + if r.TryDecodeAsNil() { + x.Href = "" + } else { + x.Href = r.DecodeString() + } + case "husnr": + if r.TryDecodeAsNil() { + x.Husnr = "" + } else { + x.Husnr = r.DecodeString() + } + case "id": + if r.TryDecodeAsNil() { + x.ID = "" + } else { + x.ID = r.DecodeString() + } + case "kommune": + if r.TryDecodeAsNil() { + x.Kommune = Kommune{} + } else { + yyv83 := &x.Kommune + yyv83.CodecDecodeSelf(d) + } + case "kvh": + if r.TryDecodeAsNil() { + x.Kvh = "" + } else { + x.Kvh = r.DecodeString() + } + case "matrikelnr": + if r.TryDecodeAsNil() { + x.Matrikelnr = "" + } else { + x.Matrikelnr = r.DecodeString() + } + case "opstillingskreds": + if r.TryDecodeAsNil() { + x.Opstillingskreds = Opstillingskreds{} + } else { + yyv86 := &x.Opstillingskreds + yyv86.CodecDecodeSelf(d) + } + case "politikreds": + if r.TryDecodeAsNil() { + x.Politikreds = Politikreds{} + } else { + yyv87 := &x.Politikreds + yyv87.CodecDecodeSelf(d) + } + case "postnummer": + if r.TryDecodeAsNil() { + x.Postnummer = PostnummerRef{} + } else { + yyv88 := &x.Postnummer + yyv88.CodecDecodeSelf(d) + } + case "region": + if r.TryDecodeAsNil() { + x.Region = Region{} + } else { + yyv89 := &x.Region + yyv89.CodecDecodeSelf(d) + } + case "retskreds": + if r.TryDecodeAsNil() { + x.Retskreds = Retskreds{} + } else { + yyv90 := &x.Retskreds + yyv90.CodecDecodeSelf(d) + } + case "sogn": + if r.TryDecodeAsNil() { + x.Sogn = Sogn{} + } else { + yyv91 := &x.Sogn + yyv91.CodecDecodeSelf(d) + } + case "status": + if r.TryDecodeAsNil() { + x.Status = 0 + } else { + x.Status = int(r.DecodeInt(codecSelferBitsize1474)) + } + case "supplerendebynavn": + if r.TryDecodeAsNil() { + x.SupplerendeBynavn = "" + } else { + x.SupplerendeBynavn = r.DecodeString() + } + case "vejstykke": + if r.TryDecodeAsNil() { + x.Vejstykke = VejstykkeRef{} + } else { + yyv94 := &x.Vejstykke + yyv94.CodecDecodeSelf(d) + } + case "zone": + if r.TryDecodeAsNil() { + x.Zone = "" + } else { + x.Zone = r.DecodeString() + } + default: + z.DecStructFieldNotFound(-1, yys74) + } // end switch yys74 + } // end for yyj74 + if !yyhl74 { + r.ReadMapEnd() + } +} + +func (x *AdgangsAdresse) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { + var h codecSelfer1474 + z, r := codec1978.GenHelperDecoder(d) + _, _, _ = h, z, r + var yyj96 int + var yyb96 bool + var yyhl96 bool = l >= 0 + yyj96++ + if yyhl96 { + yyb96 = yyj96 > l + } else { + yyb96 = r.CheckBreak() + } + if yyb96 { + r.ReadArrayEnd() + return + } + if r.TryDecodeAsNil() { + x.DDKN = DDKN{} + } else { + yyv97 := &x.DDKN + yyv97.CodecDecodeSelf(d) + } + yyj96++ + if yyhl96 { + yyb96 = yyj96 > l + } else { + yyb96 = r.CheckBreak() + } + if yyb96 { + r.ReadArrayEnd() + return + } + r.ReadArrayEntrySeparator() + if r.TryDecodeAsNil() { + x.Adgangspunkt = Adgangspunkt{} + } else { + yyv98 := &x.Adgangspunkt + yyv98.CodecDecodeSelf(d) + } + yyj96++ + if yyhl96 { + yyb96 = yyj96 > l + } else { + yyb96 = r.CheckBreak() + } + if yyb96 { + r.ReadArrayEnd() + return + } + r.ReadArrayEntrySeparator() + if r.TryDecodeAsNil() { + x.Ejerlav = Ejerlav{} + } else { + yyv99 := &x.Ejerlav + yyv99.CodecDecodeSelf(d) + } + yyj96++ + if yyhl96 { + yyb96 = yyj96 > l + } else { + yyb96 = r.CheckBreak() + } + if yyb96 { + r.ReadArrayEnd() + return + } + r.ReadArrayEntrySeparator() + if r.TryDecodeAsNil() { + x.EsrEjendomsNr = "" + } else { + x.EsrEjendomsNr = r.DecodeString() + } + yyj96++ + if yyhl96 { + yyb96 = yyj96 > l + } else { + yyb96 = r.CheckBreak() + } + if yyb96 { + r.ReadArrayEnd() + return + } + r.ReadArrayEntrySeparator() + if r.TryDecodeAsNil() { + x.Historik = Historik{} + } else { + yyv101 := &x.Historik + yyv101.CodecDecodeSelf(d) + } + yyj96++ + if yyhl96 { + yyb96 = yyj96 > l + } else { + yyb96 = r.CheckBreak() + } + if yyb96 { + r.ReadArrayEnd() + return + } + r.ReadArrayEntrySeparator() + if r.TryDecodeAsNil() { + x.Href = "" + } else { + x.Href = r.DecodeString() + } + yyj96++ + if yyhl96 { + yyb96 = yyj96 > l + } else { + yyb96 = r.CheckBreak() + } + if yyb96 { + r.ReadArrayEnd() + return + } + r.ReadArrayEntrySeparator() + if r.TryDecodeAsNil() { + x.Husnr = "" + } else { + x.Husnr = r.DecodeString() + } + yyj96++ + if yyhl96 { + yyb96 = yyj96 > l + } else { + yyb96 = r.CheckBreak() + } + if yyb96 { + r.ReadArrayEnd() + return + } + r.ReadArrayEntrySeparator() + if r.TryDecodeAsNil() { + x.ID = "" + } else { + x.ID = r.DecodeString() + } + yyj96++ + if yyhl96 { + yyb96 = yyj96 > l + } else { + yyb96 = r.CheckBreak() + } + if yyb96 { + r.ReadArrayEnd() + return + } + r.ReadArrayEntrySeparator() + if r.TryDecodeAsNil() { + x.Kommune = Kommune{} + } else { + yyv105 := &x.Kommune + yyv105.CodecDecodeSelf(d) + } + yyj96++ + if yyhl96 { + yyb96 = yyj96 > l + } else { + yyb96 = r.CheckBreak() + } + if yyb96 { + r.ReadArrayEnd() + return + } + r.ReadArrayEntrySeparator() + if r.TryDecodeAsNil() { + x.Kvh = "" + } else { + x.Kvh = r.DecodeString() + } + yyj96++ + if yyhl96 { + yyb96 = yyj96 > l + } else { + yyb96 = r.CheckBreak() + } + if yyb96 { + r.ReadArrayEnd() + return + } + r.ReadArrayEntrySeparator() + if r.TryDecodeAsNil() { + x.Matrikelnr = "" + } else { + x.Matrikelnr = r.DecodeString() + } + yyj96++ + if yyhl96 { + yyb96 = yyj96 > l + } else { + yyb96 = r.CheckBreak() + } + if yyb96 { + r.ReadArrayEnd() + return + } + r.ReadArrayEntrySeparator() + if r.TryDecodeAsNil() { + x.Opstillingskreds = Opstillingskreds{} + } else { + yyv108 := &x.Opstillingskreds + yyv108.CodecDecodeSelf(d) + } + yyj96++ + if yyhl96 { + yyb96 = yyj96 > l + } else { + yyb96 = r.CheckBreak() + } + if yyb96 { + r.ReadArrayEnd() + return + } + r.ReadArrayEntrySeparator() + if r.TryDecodeAsNil() { + x.Politikreds = Politikreds{} + } else { + yyv109 := &x.Politikreds + yyv109.CodecDecodeSelf(d) + } + yyj96++ + if yyhl96 { + yyb96 = yyj96 > l + } else { + yyb96 = r.CheckBreak() + } + if yyb96 { + r.ReadArrayEnd() + return + } + r.ReadArrayEntrySeparator() + if r.TryDecodeAsNil() { + x.Postnummer = PostnummerRef{} + } else { + yyv110 := &x.Postnummer + yyv110.CodecDecodeSelf(d) + } + yyj96++ + if yyhl96 { + yyb96 = yyj96 > l + } else { + yyb96 = r.CheckBreak() + } + if yyb96 { + r.ReadArrayEnd() + return + } + r.ReadArrayEntrySeparator() + if r.TryDecodeAsNil() { + x.Region = Region{} + } else { + yyv111 := &x.Region + yyv111.CodecDecodeSelf(d) + } + yyj96++ + if yyhl96 { + yyb96 = yyj96 > l + } else { + yyb96 = r.CheckBreak() + } + if yyb96 { + r.ReadArrayEnd() + return + } + r.ReadArrayEntrySeparator() + if r.TryDecodeAsNil() { + x.Retskreds = Retskreds{} + } else { + yyv112 := &x.Retskreds + yyv112.CodecDecodeSelf(d) + } + yyj96++ + if yyhl96 { + yyb96 = yyj96 > l + } else { + yyb96 = r.CheckBreak() + } + if yyb96 { + r.ReadArrayEnd() + return + } + r.ReadArrayEntrySeparator() + if r.TryDecodeAsNil() { + x.Sogn = Sogn{} + } else { + yyv113 := &x.Sogn + yyv113.CodecDecodeSelf(d) + } + yyj96++ + if yyhl96 { + yyb96 = yyj96 > l + } else { + yyb96 = r.CheckBreak() + } + if yyb96 { + r.ReadArrayEnd() + return + } + r.ReadArrayEntrySeparator() + if r.TryDecodeAsNil() { + x.Status = 0 + } else { + x.Status = int(r.DecodeInt(codecSelferBitsize1474)) + } + yyj96++ + if yyhl96 { + yyb96 = yyj96 > l + } else { + yyb96 = r.CheckBreak() + } + if yyb96 { + r.ReadArrayEnd() + return + } + r.ReadArrayEntrySeparator() + if r.TryDecodeAsNil() { + x.SupplerendeBynavn = "" + } else { + x.SupplerendeBynavn = r.DecodeString() + } + yyj96++ + if yyhl96 { + yyb96 = yyj96 > l + } else { + yyb96 = r.CheckBreak() + } + if yyb96 { + r.ReadArrayEnd() + return + } + r.ReadArrayEntrySeparator() + if r.TryDecodeAsNil() { + x.Vejstykke = VejstykkeRef{} + } else { + yyv116 := &x.Vejstykke + yyv116.CodecDecodeSelf(d) + } + yyj96++ + if yyhl96 { + yyb96 = yyj96 > l + } else { + yyb96 = r.CheckBreak() + } + if yyb96 { + r.ReadArrayEnd() + return + } + r.ReadArrayEntrySeparator() + if r.TryDecodeAsNil() { + x.Zone = "" + } else { + x.Zone = r.DecodeString() + } + for { + yyj96++ + if yyhl96 { + yyb96 = yyj96 > l + } else { + yyb96 = r.CheckBreak() + } + if yyb96 { + break + } + if yyj96 > 1 { + r.ReadArrayEntrySeparator() + } + z.DecStructFieldNotFound(yyj96-1, "") + } + r.ReadArrayEnd() +} + +func (x *DDKN) CodecEncodeSelf(e *codec1978.Encoder) { + var h codecSelfer1474 + z, r := codec1978.GenHelperEncoder(e) + _, _, _ = h, z, r + if x == nil { + r.EncodeNil() + } else { + yysep118 := !z.EncBinary() + const yyr118 bool = false + var yyq118 [3]bool + if yyr118 || z.EncBasicHandle().StructToArray { + r.EncodeArrayStart(3) + } else { + var yynn118 int = 3 + for _, b := range yyq118 { + if b { + yynn118++ + } + } + r.EncodeMapStart(yynn118) + } + if yyr118 || z.EncBasicHandle().StructToArray { + r.EncodeString(codecSelferC_UTF81474, string(x.Km1)) + } else { + r.EncodeString(codecSelferC_UTF81474, string("Km1")) + if yysep118 { + r.EncodeMapKVSeparator() + } + r.EncodeString(codecSelferC_UTF81474, string(x.Km1)) + } + if yyr118 || z.EncBasicHandle().StructToArray { + if yysep118 { + r.EncodeArrayEntrySeparator() + } + r.EncodeString(codecSelferC_UTF81474, string(x.Km10)) + } else { + if yysep118 { + r.EncodeMapEntrySeparator() + } + r.EncodeString(codecSelferC_UTF81474, string("Km10")) + if yysep118 { + r.EncodeMapKVSeparator() + } + r.EncodeString(codecSelferC_UTF81474, string(x.Km10)) + } + if yyr118 || z.EncBasicHandle().StructToArray { + if yysep118 { + r.EncodeArrayEntrySeparator() + } + r.EncodeString(codecSelferC_UTF81474, string(x.M100)) + } else { + if yysep118 { + r.EncodeMapEntrySeparator() + } + r.EncodeString(codecSelferC_UTF81474, string("M100")) + if yysep118 { + r.EncodeMapKVSeparator() + } + r.EncodeString(codecSelferC_UTF81474, string(x.M100)) + } + if yysep118 { + if yyr118 || z.EncBasicHandle().StructToArray { + r.EncodeArrayEnd() + } else { + r.EncodeMapEnd() + } + } + } +} + +func (x *DDKN) CodecDecodeSelf(d *codec1978.Decoder) { + var h codecSelfer1474 + z, r := codec1978.GenHelperDecoder(d) + _, _, _ = h, z, r + if r.IsContainerType(codecSelverValueTypeMap1474) { + yyl122 := r.ReadMapStart() + if yyl122 == 0 { + r.ReadMapEnd() + } else { + x.codecDecodeSelfFromMap(yyl122, d) + } + } else if r.IsContainerType(codecSelverValueTypeArray1474) { + yyl122 := r.ReadArrayStart() + if yyl122 == 0 { + r.ReadArrayEnd() + } else { + x.codecDecodeSelfFromArray(yyl122, d) + } + } else { + panic(codecSelferOnlyMapOrArrayEncodeToStructErr1474) + } +} + +func (x *DDKN) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) { + var h codecSelfer1474 + z, r := codec1978.GenHelperDecoder(d) + _, _, _ = h, z, r + var yys123Slc = z.DecScratchBuffer() // default slice to decode into + _ = yys123Slc + var yyhl123 bool = l >= 0 + for yyj123 := 0; ; yyj123++ { + if yyhl123 { + if yyj123 >= l { + break + } + } else { + if r.CheckBreak() { + break + } + if yyj123 > 0 { + r.ReadMapEntrySeparator() + } + } + yys123Slc = r.DecodeBytes(yys123Slc, true, true) + yys123 := string(yys123Slc) + if !yyhl123 { + r.ReadMapKVSeparator() + } + switch yys123 { + case "km1": + if r.TryDecodeAsNil() { + x.Km1 = "" + } else { + x.Km1 = r.DecodeString() + } + case "km10": + if r.TryDecodeAsNil() { + x.Km10 = "" + } else { + x.Km10 = r.DecodeString() + } + case "m100": + if r.TryDecodeAsNil() { + x.M100 = "" + } else { + x.M100 = r.DecodeString() + } + default: + z.DecStructFieldNotFound(-1, yys123) + } // end switch yys123 + } // end for yyj123 + if !yyhl123 { + r.ReadMapEnd() + } +} + +func (x *DDKN) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { + var h codecSelfer1474 + z, r := codec1978.GenHelperDecoder(d) + _, _, _ = h, z, r + var yyj127 int + var yyb127 bool + var yyhl127 bool = l >= 0 + yyj127++ + if yyhl127 { + yyb127 = yyj127 > l + } else { + yyb127 = r.CheckBreak() + } + if yyb127 { + r.ReadArrayEnd() + return + } + if r.TryDecodeAsNil() { + x.Km1 = "" + } else { + x.Km1 = r.DecodeString() + } + yyj127++ + if yyhl127 { + yyb127 = yyj127 > l + } else { + yyb127 = r.CheckBreak() + } + if yyb127 { + r.ReadArrayEnd() + return + } + r.ReadArrayEntrySeparator() + if r.TryDecodeAsNil() { + x.Km10 = "" + } else { + x.Km10 = r.DecodeString() + } + yyj127++ + if yyhl127 { + yyb127 = yyj127 > l + } else { + yyb127 = r.CheckBreak() + } + if yyb127 { + r.ReadArrayEnd() + return + } + r.ReadArrayEntrySeparator() + if r.TryDecodeAsNil() { + x.M100 = "" + } else { + x.M100 = r.DecodeString() + } + for { + yyj127++ + if yyhl127 { + yyb127 = yyj127 > l + } else { + yyb127 = r.CheckBreak() + } + if yyb127 { + break + } + if yyj127 > 1 { + r.ReadArrayEntrySeparator() + } + z.DecStructFieldNotFound(yyj127-1, "") + } + r.ReadArrayEnd() +} + +func (x *Adgangspunkt) CodecEncodeSelf(e *codec1978.Encoder) { + var h codecSelfer1474 + z, r := codec1978.GenHelperEncoder(e) + _, _, _ = h, z, r + if x == nil { + r.EncodeNil() + } else { + yysep131 := !z.EncBinary() + const yyr131 bool = false + var yyq131 [6]bool + if yyr131 || z.EncBasicHandle().StructToArray { + r.EncodeArrayStart(6) + } else { + var yynn131 int = 6 + for _, b := range yyq131 { + if b { + yynn131++ + } + } + r.EncodeMapStart(yynn131) + } + if yyr131 || z.EncBasicHandle().StructToArray { + r.EncodeInt(int64(x.Kilde)) + } else { + r.EncodeString(codecSelferC_UTF81474, string("Kilde")) + if yysep131 { + r.EncodeMapKVSeparator() + } + r.EncodeInt(int64(x.Kilde)) + } + if yyr131 || z.EncBasicHandle().StructToArray { + if yysep131 { + r.EncodeArrayEntrySeparator() + } + if x.Koordinater == nil { + r.EncodeNil() + } else { + z.F.EncSliceFloat64V(x.Koordinater, false, e) + } + } else { + if yysep131 { + r.EncodeMapEntrySeparator() + } + r.EncodeString(codecSelferC_UTF81474, string("Koordinater")) + if yysep131 { + r.EncodeMapKVSeparator() + } + if x.Koordinater == nil { + r.EncodeNil() + } else { + z.F.EncSliceFloat64V(x.Koordinater, false, e) + } + } + if yyr131 || z.EncBasicHandle().StructToArray { + if yysep131 { + r.EncodeArrayEntrySeparator() + } + r.EncodeString(codecSelferC_UTF81474, string(x.Nøjagtighed)) + } else { + if yysep131 { + r.EncodeMapEntrySeparator() + } + r.EncodeString(codecSelferC_UTF81474, string("Nøjagtighed")) + if yysep131 { + r.EncodeMapKVSeparator() + } + r.EncodeString(codecSelferC_UTF81474, string(x.Nøjagtighed)) + } + if yyr131 || z.EncBasicHandle().StructToArray { + if yysep131 { + r.EncodeArrayEntrySeparator() + } + r.EncodeString(codecSelferC_UTF81474, string(x.Tekniskstandard)) + } else { + if yysep131 { + r.EncodeMapEntrySeparator() + } + r.EncodeString(codecSelferC_UTF81474, string("Tekniskstandard")) + if yysep131 { + r.EncodeMapKVSeparator() + } + r.EncodeString(codecSelferC_UTF81474, string(x.Tekniskstandard)) + } + if yyr131 || z.EncBasicHandle().StructToArray { + if yysep131 { + r.EncodeArrayEntrySeparator() + } + r.EncodeFloat64(float64(x.Tekstretning)) + } else { + if yysep131 { + r.EncodeMapEntrySeparator() + } + r.EncodeString(codecSelferC_UTF81474, string("Tekstretning")) + if yysep131 { + r.EncodeMapKVSeparator() + } + r.EncodeFloat64(float64(x.Tekstretning)) + } + if yyr131 || z.EncBasicHandle().StructToArray { + if yysep131 { + r.EncodeArrayEntrySeparator() + } + z.EncFallback(x.Ændret) + } else { + if yysep131 { + r.EncodeMapEntrySeparator() + } + r.EncodeString(codecSelferC_UTF81474, string("Ændret")) + if yysep131 { + r.EncodeMapKVSeparator() + } + z.EncFallback(x.Ændret) + } + if yysep131 { + if yyr131 || z.EncBasicHandle().StructToArray { + r.EncodeArrayEnd() + } else { + r.EncodeMapEnd() + } + } + } +} + +func (x *Adgangspunkt) CodecDecodeSelf(d *codec1978.Decoder) { + var h codecSelfer1474 + z, r := codec1978.GenHelperDecoder(d) + _, _, _ = h, z, r + if r.IsContainerType(codecSelverValueTypeMap1474) { + yyl138 := r.ReadMapStart() + if yyl138 == 0 { + r.ReadMapEnd() + } else { + x.codecDecodeSelfFromMap(yyl138, d) + } + } else if r.IsContainerType(codecSelverValueTypeArray1474) { + yyl138 := r.ReadArrayStart() + if yyl138 == 0 { + r.ReadArrayEnd() + } else { + x.codecDecodeSelfFromArray(yyl138, d) + } + } else { + panic(codecSelferOnlyMapOrArrayEncodeToStructErr1474) + } +} + +func (x *Adgangspunkt) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) { + var h codecSelfer1474 + z, r := codec1978.GenHelperDecoder(d) + _, _, _ = h, z, r + var yys139Slc = z.DecScratchBuffer() // default slice to decode into + _ = yys139Slc + var yyhl139 bool = l >= 0 + for yyj139 := 0; ; yyj139++ { + if yyhl139 { + if yyj139 >= l { + break + } + } else { + if r.CheckBreak() { + break + } + if yyj139 > 0 { + r.ReadMapEntrySeparator() + } + } + yys139Slc = r.DecodeBytes(yys139Slc, true, true) + yys139 := string(yys139Slc) + if !yyhl139 { + r.ReadMapKVSeparator() + } + switch yys139 { + case "kilde": + if r.TryDecodeAsNil() { + x.Kilde = 0 + } else { + x.Kilde = int(r.DecodeInt(codecSelferBitsize1474)) + } + case "koordinater": + if r.TryDecodeAsNil() { + x.Koordinater = nil + } else { + yyv141 := &x.Koordinater + z.F.DecSliceFloat64X(yyv141, false, d) + } + case "nøjagtighed": + if r.TryDecodeAsNil() { + x.Nøjagtighed = "" + } else { + x.Nøjagtighed = r.DecodeString() + } + case "tekniskstandard": + if r.TryDecodeAsNil() { + x.Tekniskstandard = "" + } else { + x.Tekniskstandard = r.DecodeString() + } + case "tekstretning": + if r.TryDecodeAsNil() { + x.Tekstretning = 0 + } else { + x.Tekstretning = float64(r.DecodeFloat(false)) + } + case "ændret": + if r.TryDecodeAsNil() { + x.Ændret = AwsTime{} + } else { + yyv145 := &x.Ændret + z.DecFallback(yyv145, false) + } + default: + z.DecStructFieldNotFound(-1, yys139) + } // end switch yys139 + } // end for yyj139 + if !yyhl139 { + r.ReadMapEnd() + } +} + +func (x *Adgangspunkt) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { + var h codecSelfer1474 + z, r := codec1978.GenHelperDecoder(d) + _, _, _ = h, z, r + var yyj146 int + var yyb146 bool + var yyhl146 bool = l >= 0 + yyj146++ + if yyhl146 { + yyb146 = yyj146 > l + } else { + yyb146 = r.CheckBreak() + } + if yyb146 { + r.ReadArrayEnd() + return + } + if r.TryDecodeAsNil() { + x.Kilde = 0 + } else { + x.Kilde = int(r.DecodeInt(codecSelferBitsize1474)) + } + yyj146++ + if yyhl146 { + yyb146 = yyj146 > l + } else { + yyb146 = r.CheckBreak() + } + if yyb146 { + r.ReadArrayEnd() + return + } + r.ReadArrayEntrySeparator() + if r.TryDecodeAsNil() { + x.Koordinater = nil + } else { + yyv148 := &x.Koordinater + z.F.DecSliceFloat64X(yyv148, false, d) + } + yyj146++ + if yyhl146 { + yyb146 = yyj146 > l + } else { + yyb146 = r.CheckBreak() + } + if yyb146 { + r.ReadArrayEnd() + return + } + r.ReadArrayEntrySeparator() + if r.TryDecodeAsNil() { + x.Nøjagtighed = "" + } else { + x.Nøjagtighed = r.DecodeString() + } + yyj146++ + if yyhl146 { + yyb146 = yyj146 > l + } else { + yyb146 = r.CheckBreak() + } + if yyb146 { + r.ReadArrayEnd() + return + } + r.ReadArrayEntrySeparator() + if r.TryDecodeAsNil() { + x.Tekniskstandard = "" + } else { + x.Tekniskstandard = r.DecodeString() + } + yyj146++ + if yyhl146 { + yyb146 = yyj146 > l + } else { + yyb146 = r.CheckBreak() + } + if yyb146 { + r.ReadArrayEnd() + return + } + r.ReadArrayEntrySeparator() + if r.TryDecodeAsNil() { + x.Tekstretning = 0 + } else { + x.Tekstretning = float64(r.DecodeFloat(false)) + } + yyj146++ + if yyhl146 { + yyb146 = yyj146 > l + } else { + yyb146 = r.CheckBreak() + } + if yyb146 { + r.ReadArrayEnd() + return + } + r.ReadArrayEntrySeparator() + if r.TryDecodeAsNil() { + x.Ændret = AwsTime{} + } else { + yyv152 := &x.Ændret + z.DecFallback(yyv152, false) + } + for { + yyj146++ + if yyhl146 { + yyb146 = yyj146 > l + } else { + yyb146 = r.CheckBreak() + } + if yyb146 { + break + } + if yyj146 > 1 { + r.ReadArrayEntrySeparator() + } + z.DecStructFieldNotFound(yyj146-1, "") + } + r.ReadArrayEnd() +} + +func (x *Ejerlav) CodecEncodeSelf(e *codec1978.Encoder) { + var h codecSelfer1474 + z, r := codec1978.GenHelperEncoder(e) + _, _, _ = h, z, r + if x == nil { + r.EncodeNil() + } else { + yysep153 := !z.EncBinary() + const yyr153 bool = false + var yyq153 [2]bool + if yyr153 || z.EncBasicHandle().StructToArray { + r.EncodeArrayStart(2) + } else { + var yynn153 int = 2 + for _, b := range yyq153 { + if b { + yynn153++ + } + } + r.EncodeMapStart(yynn153) + } + if yyr153 || z.EncBasicHandle().StructToArray { + r.EncodeInt(int64(x.Kode)) + } else { + r.EncodeString(codecSelferC_UTF81474, string("Kode")) + if yysep153 { + r.EncodeMapKVSeparator() + } + r.EncodeInt(int64(x.Kode)) + } + if yyr153 || z.EncBasicHandle().StructToArray { + if yysep153 { + r.EncodeArrayEntrySeparator() + } + r.EncodeString(codecSelferC_UTF81474, string(x.Navn)) + } else { + if yysep153 { + r.EncodeMapEntrySeparator() + } + r.EncodeString(codecSelferC_UTF81474, string("Navn")) + if yysep153 { + r.EncodeMapKVSeparator() + } + r.EncodeString(codecSelferC_UTF81474, string(x.Navn)) + } + if yysep153 { + if yyr153 || z.EncBasicHandle().StructToArray { + r.EncodeArrayEnd() + } else { + r.EncodeMapEnd() + } + } + } +} + +func (x *Ejerlav) CodecDecodeSelf(d *codec1978.Decoder) { + var h codecSelfer1474 + z, r := codec1978.GenHelperDecoder(d) + _, _, _ = h, z, r + if r.IsContainerType(codecSelverValueTypeMap1474) { + yyl156 := r.ReadMapStart() + if yyl156 == 0 { + r.ReadMapEnd() + } else { + x.codecDecodeSelfFromMap(yyl156, d) + } + } else if r.IsContainerType(codecSelverValueTypeArray1474) { + yyl156 := r.ReadArrayStart() + if yyl156 == 0 { + r.ReadArrayEnd() + } else { + x.codecDecodeSelfFromArray(yyl156, d) + } + } else { + panic(codecSelferOnlyMapOrArrayEncodeToStructErr1474) + } +} + +func (x *Ejerlav) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) { + var h codecSelfer1474 + z, r := codec1978.GenHelperDecoder(d) + _, _, _ = h, z, r + var yys157Slc = z.DecScratchBuffer() // default slice to decode into + _ = yys157Slc + var yyhl157 bool = l >= 0 + for yyj157 := 0; ; yyj157++ { + if yyhl157 { + if yyj157 >= l { + break + } + } else { + if r.CheckBreak() { + break + } + if yyj157 > 0 { + r.ReadMapEntrySeparator() + } + } + yys157Slc = r.DecodeBytes(yys157Slc, true, true) + yys157 := string(yys157Slc) + if !yyhl157 { + r.ReadMapKVSeparator() + } + switch yys157 { + case "kode": + if r.TryDecodeAsNil() { + x.Kode = 0 + } else { + x.Kode = int(r.DecodeInt(codecSelferBitsize1474)) + } + case "navn": + if r.TryDecodeAsNil() { + x.Navn = "" + } else { + x.Navn = r.DecodeString() + } + default: + z.DecStructFieldNotFound(-1, yys157) + } // end switch yys157 + } // end for yyj157 + if !yyhl157 { + r.ReadMapEnd() + } +} + +func (x *Ejerlav) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { + var h codecSelfer1474 + z, r := codec1978.GenHelperDecoder(d) + _, _, _ = h, z, r + var yyj160 int + var yyb160 bool + var yyhl160 bool = l >= 0 + yyj160++ + if yyhl160 { + yyb160 = yyj160 > l + } else { + yyb160 = r.CheckBreak() + } + if yyb160 { + r.ReadArrayEnd() + return + } + if r.TryDecodeAsNil() { + x.Kode = 0 + } else { + x.Kode = int(r.DecodeInt(codecSelferBitsize1474)) + } + yyj160++ + if yyhl160 { + yyb160 = yyj160 > l + } else { + yyb160 = r.CheckBreak() + } + if yyb160 { + r.ReadArrayEnd() + return + } + r.ReadArrayEntrySeparator() + if r.TryDecodeAsNil() { + x.Navn = "" + } else { + x.Navn = r.DecodeString() + } + for { + yyj160++ + if yyhl160 { + yyb160 = yyj160 > l + } else { + yyb160 = r.CheckBreak() + } + if yyb160 { + break + } + if yyj160 > 1 { + r.ReadArrayEntrySeparator() + } + z.DecStructFieldNotFound(yyj160-1, "") + } + r.ReadArrayEnd() +} + +func (x *Historik) CodecEncodeSelf(e *codec1978.Encoder) { + var h codecSelfer1474 + z, r := codec1978.GenHelperEncoder(e) + _, _, _ = h, z, r + if x == nil { + r.EncodeNil() + } else { + yysep163 := !z.EncBinary() + const yyr163 bool = false + var yyq163 [2]bool + if yyr163 || z.EncBasicHandle().StructToArray { + r.EncodeArrayStart(2) + } else { + var yynn163 int = 2 + for _, b := range yyq163 { + if b { + yynn163++ + } + } + r.EncodeMapStart(yynn163) + } + if yyr163 || z.EncBasicHandle().StructToArray { + z.EncFallback(x.Oprettet) + } else { + r.EncodeString(codecSelferC_UTF81474, string("Oprettet")) + if yysep163 { + r.EncodeMapKVSeparator() + } + z.EncFallback(x.Oprettet) + } + if yyr163 || z.EncBasicHandle().StructToArray { + if yysep163 { + r.EncodeArrayEntrySeparator() + } + z.EncFallback(x.Ændret) + } else { + if yysep163 { + r.EncodeMapEntrySeparator() + } + r.EncodeString(codecSelferC_UTF81474, string("Ændret")) + if yysep163 { + r.EncodeMapKVSeparator() + } + z.EncFallback(x.Ændret) + } + if yysep163 { + if yyr163 || z.EncBasicHandle().StructToArray { + r.EncodeArrayEnd() + } else { + r.EncodeMapEnd() + } + } + } +} + +func (x *Historik) CodecDecodeSelf(d *codec1978.Decoder) { + var h codecSelfer1474 + z, r := codec1978.GenHelperDecoder(d) + _, _, _ = h, z, r + if r.IsContainerType(codecSelverValueTypeMap1474) { + yyl166 := r.ReadMapStart() + if yyl166 == 0 { + r.ReadMapEnd() + } else { + x.codecDecodeSelfFromMap(yyl166, d) + } + } else if r.IsContainerType(codecSelverValueTypeArray1474) { + yyl166 := r.ReadArrayStart() + if yyl166 == 0 { + r.ReadArrayEnd() + } else { + x.codecDecodeSelfFromArray(yyl166, d) + } + } else { + panic(codecSelferOnlyMapOrArrayEncodeToStructErr1474) + } +} + +func (x *Historik) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) { + var h codecSelfer1474 + z, r := codec1978.GenHelperDecoder(d) + _, _, _ = h, z, r + var yys167Slc = z.DecScratchBuffer() // default slice to decode into + _ = yys167Slc + var yyhl167 bool = l >= 0 + for yyj167 := 0; ; yyj167++ { + if yyhl167 { + if yyj167 >= l { + break + } + } else { + if r.CheckBreak() { + break + } + if yyj167 > 0 { + r.ReadMapEntrySeparator() + } + } + yys167Slc = r.DecodeBytes(yys167Slc, true, true) + yys167 := string(yys167Slc) + if !yyhl167 { + r.ReadMapKVSeparator() + } + switch yys167 { + case "oprettet": + if r.TryDecodeAsNil() { + x.Oprettet = AwsTime{} + } else { + yyv168 := &x.Oprettet + z.DecFallback(yyv168, false) + } + case "ændret": + if r.TryDecodeAsNil() { + x.Ændret = AwsTime{} + } else { + yyv169 := &x.Ændret + z.DecFallback(yyv169, false) + } + default: + z.DecStructFieldNotFound(-1, yys167) + } // end switch yys167 + } // end for yyj167 + if !yyhl167 { + r.ReadMapEnd() + } +} + +func (x *Historik) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { + var h codecSelfer1474 + z, r := codec1978.GenHelperDecoder(d) + _, _, _ = h, z, r + var yyj170 int + var yyb170 bool + var yyhl170 bool = l >= 0 + yyj170++ + if yyhl170 { + yyb170 = yyj170 > l + } else { + yyb170 = r.CheckBreak() + } + if yyb170 { + r.ReadArrayEnd() + return + } + if r.TryDecodeAsNil() { + x.Oprettet = AwsTime{} + } else { + yyv171 := &x.Oprettet + z.DecFallback(yyv171, false) + } + yyj170++ + if yyhl170 { + yyb170 = yyj170 > l + } else { + yyb170 = r.CheckBreak() + } + if yyb170 { + r.ReadArrayEnd() + return + } + r.ReadArrayEntrySeparator() + if r.TryDecodeAsNil() { + x.Ændret = AwsTime{} + } else { + yyv172 := &x.Ændret + z.DecFallback(yyv172, false) + } + for { + yyj170++ + if yyhl170 { + yyb170 = yyj170 > l + } else { + yyb170 = r.CheckBreak() + } + if yyb170 { + break + } + if yyj170 > 1 { + r.ReadArrayEntrySeparator() + } + z.DecStructFieldNotFound(yyj170-1, "") + } + r.ReadArrayEnd() +} + +func (x *Kommune) CodecEncodeSelf(e *codec1978.Encoder) { + var h codecSelfer1474 + z, r := codec1978.GenHelperEncoder(e) + _, _, _ = h, z, r + if x == nil { + r.EncodeNil() + } else { + yysep173 := !z.EncBinary() + const yyr173 bool = false + var yyq173 [3]bool + if yyr173 || z.EncBasicHandle().StructToArray { + r.EncodeArrayStart(3) + } else { + var yynn173 int = 3 + for _, b := range yyq173 { + if b { + yynn173++ + } + } + r.EncodeMapStart(yynn173) + } + if yyr173 || z.EncBasicHandle().StructToArray { + r.EncodeString(codecSelferC_UTF81474, string(x.Href)) + } else { + r.EncodeString(codecSelferC_UTF81474, string("Href")) + if yysep173 { + r.EncodeMapKVSeparator() + } + r.EncodeString(codecSelferC_UTF81474, string(x.Href)) + } + if yyr173 || z.EncBasicHandle().StructToArray { + if yysep173 { + r.EncodeArrayEntrySeparator() + } + r.EncodeString(codecSelferC_UTF81474, string(x.Kode)) + } else { + if yysep173 { + r.EncodeMapEntrySeparator() + } + r.EncodeString(codecSelferC_UTF81474, string("Kode")) + if yysep173 { + r.EncodeMapKVSeparator() + } + r.EncodeString(codecSelferC_UTF81474, string(x.Kode)) + } + if yyr173 || z.EncBasicHandle().StructToArray { + if yysep173 { + r.EncodeArrayEntrySeparator() + } + r.EncodeString(codecSelferC_UTF81474, string(x.Navn)) + } else { + if yysep173 { + r.EncodeMapEntrySeparator() + } + r.EncodeString(codecSelferC_UTF81474, string("Navn")) + if yysep173 { + r.EncodeMapKVSeparator() + } + r.EncodeString(codecSelferC_UTF81474, string(x.Navn)) + } + if yysep173 { + if yyr173 || z.EncBasicHandle().StructToArray { + r.EncodeArrayEnd() + } else { + r.EncodeMapEnd() + } + } + } +} + +func (x *Kommune) CodecDecodeSelf(d *codec1978.Decoder) { + var h codecSelfer1474 + z, r := codec1978.GenHelperDecoder(d) + _, _, _ = h, z, r + if r.IsContainerType(codecSelverValueTypeMap1474) { + yyl177 := r.ReadMapStart() + if yyl177 == 0 { + r.ReadMapEnd() + } else { + x.codecDecodeSelfFromMap(yyl177, d) + } + } else if r.IsContainerType(codecSelverValueTypeArray1474) { + yyl177 := r.ReadArrayStart() + if yyl177 == 0 { + r.ReadArrayEnd() + } else { + x.codecDecodeSelfFromArray(yyl177, d) + } + } else { + panic(codecSelferOnlyMapOrArrayEncodeToStructErr1474) + } +} + +func (x *Kommune) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) { + var h codecSelfer1474 + z, r := codec1978.GenHelperDecoder(d) + _, _, _ = h, z, r + var yys178Slc = z.DecScratchBuffer() // default slice to decode into + _ = yys178Slc + var yyhl178 bool = l >= 0 + for yyj178 := 0; ; yyj178++ { + if yyhl178 { + if yyj178 >= l { + break + } + } else { + if r.CheckBreak() { + break + } + if yyj178 > 0 { + r.ReadMapEntrySeparator() + } + } + yys178Slc = r.DecodeBytes(yys178Slc, true, true) + yys178 := string(yys178Slc) + if !yyhl178 { + r.ReadMapKVSeparator() + } + switch yys178 { + case "href": + if r.TryDecodeAsNil() { + x.Href = "" + } else { + x.Href = r.DecodeString() + } + case "kode": + if r.TryDecodeAsNil() { + x.Kode = "" + } else { + x.Kode = r.DecodeString() + } + case "navn": + if r.TryDecodeAsNil() { + x.Navn = "" + } else { + x.Navn = r.DecodeString() + } + default: + z.DecStructFieldNotFound(-1, yys178) + } // end switch yys178 + } // end for yyj178 + if !yyhl178 { + r.ReadMapEnd() + } +} + +func (x *Kommune) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { + var h codecSelfer1474 + z, r := codec1978.GenHelperDecoder(d) + _, _, _ = h, z, r + var yyj182 int + var yyb182 bool + var yyhl182 bool = l >= 0 + yyj182++ + if yyhl182 { + yyb182 = yyj182 > l + } else { + yyb182 = r.CheckBreak() + } + if yyb182 { + r.ReadArrayEnd() + return + } + if r.TryDecodeAsNil() { + x.Href = "" + } else { + x.Href = r.DecodeString() + } + yyj182++ + if yyhl182 { + yyb182 = yyj182 > l + } else { + yyb182 = r.CheckBreak() + } + if yyb182 { + r.ReadArrayEnd() + return + } + r.ReadArrayEntrySeparator() + if r.TryDecodeAsNil() { + x.Kode = "" + } else { + x.Kode = r.DecodeString() + } + yyj182++ + if yyhl182 { + yyb182 = yyj182 > l + } else { + yyb182 = r.CheckBreak() + } + if yyb182 { + r.ReadArrayEnd() + return + } + r.ReadArrayEntrySeparator() + if r.TryDecodeAsNil() { + x.Navn = "" + } else { + x.Navn = r.DecodeString() + } + for { + yyj182++ + if yyhl182 { + yyb182 = yyj182 > l + } else { + yyb182 = r.CheckBreak() + } + if yyb182 { + break + } + if yyj182 > 1 { + r.ReadArrayEntrySeparator() + } + z.DecStructFieldNotFound(yyj182-1, "") + } + r.ReadArrayEnd() +} + +func (x *Opstillingskreds) CodecEncodeSelf(e *codec1978.Encoder) { + var h codecSelfer1474 + z, r := codec1978.GenHelperEncoder(e) + _, _, _ = h, z, r + if x == nil { + r.EncodeNil() + } else { + yysep186 := !z.EncBinary() + const yyr186 bool = false + var yyq186 [3]bool + if yyr186 || z.EncBasicHandle().StructToArray { + r.EncodeArrayStart(3) + } else { + var yynn186 int = 3 + for _, b := range yyq186 { + if b { + yynn186++ + } + } + r.EncodeMapStart(yynn186) + } + if yyr186 || z.EncBasicHandle().StructToArray { + r.EncodeString(codecSelferC_UTF81474, string(x.Href)) + } else { + r.EncodeString(codecSelferC_UTF81474, string("Href")) + if yysep186 { + r.EncodeMapKVSeparator() + } + r.EncodeString(codecSelferC_UTF81474, string(x.Href)) + } + if yyr186 || z.EncBasicHandle().StructToArray { + if yysep186 { + r.EncodeArrayEntrySeparator() + } + r.EncodeString(codecSelferC_UTF81474, string(x.Kode)) + } else { + if yysep186 { + r.EncodeMapEntrySeparator() + } + r.EncodeString(codecSelferC_UTF81474, string("Kode")) + if yysep186 { + r.EncodeMapKVSeparator() + } + r.EncodeString(codecSelferC_UTF81474, string(x.Kode)) + } + if yyr186 || z.EncBasicHandle().StructToArray { + if yysep186 { + r.EncodeArrayEntrySeparator() + } + r.EncodeString(codecSelferC_UTF81474, string(x.Navn)) + } else { + if yysep186 { + r.EncodeMapEntrySeparator() + } + r.EncodeString(codecSelferC_UTF81474, string("Navn")) + if yysep186 { + r.EncodeMapKVSeparator() + } + r.EncodeString(codecSelferC_UTF81474, string(x.Navn)) + } + if yysep186 { + if yyr186 || z.EncBasicHandle().StructToArray { + r.EncodeArrayEnd() + } else { + r.EncodeMapEnd() + } + } + } +} + +func (x *Opstillingskreds) CodecDecodeSelf(d *codec1978.Decoder) { + var h codecSelfer1474 + z, r := codec1978.GenHelperDecoder(d) + _, _, _ = h, z, r + if r.IsContainerType(codecSelverValueTypeMap1474) { + yyl190 := r.ReadMapStart() + if yyl190 == 0 { + r.ReadMapEnd() + } else { + x.codecDecodeSelfFromMap(yyl190, d) + } + } else if r.IsContainerType(codecSelverValueTypeArray1474) { + yyl190 := r.ReadArrayStart() + if yyl190 == 0 { + r.ReadArrayEnd() + } else { + x.codecDecodeSelfFromArray(yyl190, d) + } + } else { + panic(codecSelferOnlyMapOrArrayEncodeToStructErr1474) + } +} + +func (x *Opstillingskreds) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) { + var h codecSelfer1474 + z, r := codec1978.GenHelperDecoder(d) + _, _, _ = h, z, r + var yys191Slc = z.DecScratchBuffer() // default slice to decode into + _ = yys191Slc + var yyhl191 bool = l >= 0 + for yyj191 := 0; ; yyj191++ { + if yyhl191 { + if yyj191 >= l { + break + } + } else { + if r.CheckBreak() { + break + } + if yyj191 > 0 { + r.ReadMapEntrySeparator() + } + } + yys191Slc = r.DecodeBytes(yys191Slc, true, true) + yys191 := string(yys191Slc) + if !yyhl191 { + r.ReadMapKVSeparator() + } + switch yys191 { + case "href": + if r.TryDecodeAsNil() { + x.Href = "" + } else { + x.Href = r.DecodeString() + } + case "kode": + if r.TryDecodeAsNil() { + x.Kode = "" + } else { + x.Kode = r.DecodeString() + } + case "navn": + if r.TryDecodeAsNil() { + x.Navn = "" + } else { + x.Navn = r.DecodeString() + } + default: + z.DecStructFieldNotFound(-1, yys191) + } // end switch yys191 + } // end for yyj191 + if !yyhl191 { + r.ReadMapEnd() + } +} + +func (x *Opstillingskreds) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { + var h codecSelfer1474 + z, r := codec1978.GenHelperDecoder(d) + _, _, _ = h, z, r + var yyj195 int + var yyb195 bool + var yyhl195 bool = l >= 0 + yyj195++ + if yyhl195 { + yyb195 = yyj195 > l + } else { + yyb195 = r.CheckBreak() + } + if yyb195 { + r.ReadArrayEnd() + return + } + if r.TryDecodeAsNil() { + x.Href = "" + } else { + x.Href = r.DecodeString() + } + yyj195++ + if yyhl195 { + yyb195 = yyj195 > l + } else { + yyb195 = r.CheckBreak() + } + if yyb195 { + r.ReadArrayEnd() + return + } + r.ReadArrayEntrySeparator() + if r.TryDecodeAsNil() { + x.Kode = "" + } else { + x.Kode = r.DecodeString() + } + yyj195++ + if yyhl195 { + yyb195 = yyj195 > l + } else { + yyb195 = r.CheckBreak() + } + if yyb195 { + r.ReadArrayEnd() + return + } + r.ReadArrayEntrySeparator() + if r.TryDecodeAsNil() { + x.Navn = "" + } else { + x.Navn = r.DecodeString() + } + for { + yyj195++ + if yyhl195 { + yyb195 = yyj195 > l + } else { + yyb195 = r.CheckBreak() + } + if yyb195 { + break + } + if yyj195 > 1 { + r.ReadArrayEntrySeparator() + } + z.DecStructFieldNotFound(yyj195-1, "") + } + r.ReadArrayEnd() +} + +func (x *Politikreds) CodecEncodeSelf(e *codec1978.Encoder) { + var h codecSelfer1474 + z, r := codec1978.GenHelperEncoder(e) + _, _, _ = h, z, r + if x == nil { + r.EncodeNil() + } else { + yysep199 := !z.EncBinary() + const yyr199 bool = false + var yyq199 [3]bool + if yyr199 || z.EncBasicHandle().StructToArray { + r.EncodeArrayStart(3) + } else { + var yynn199 int = 3 + for _, b := range yyq199 { + if b { + yynn199++ + } + } + r.EncodeMapStart(yynn199) + } + if yyr199 || z.EncBasicHandle().StructToArray { + r.EncodeString(codecSelferC_UTF81474, string(x.Href)) + } else { + r.EncodeString(codecSelferC_UTF81474, string("Href")) + if yysep199 { + r.EncodeMapKVSeparator() + } + r.EncodeString(codecSelferC_UTF81474, string(x.Href)) + } + if yyr199 || z.EncBasicHandle().StructToArray { + if yysep199 { + r.EncodeArrayEntrySeparator() + } + r.EncodeString(codecSelferC_UTF81474, string(x.Kode)) + } else { + if yysep199 { + r.EncodeMapEntrySeparator() + } + r.EncodeString(codecSelferC_UTF81474, string("Kode")) + if yysep199 { + r.EncodeMapKVSeparator() + } + r.EncodeString(codecSelferC_UTF81474, string(x.Kode)) + } + if yyr199 || z.EncBasicHandle().StructToArray { + if yysep199 { + r.EncodeArrayEntrySeparator() + } + r.EncodeString(codecSelferC_UTF81474, string(x.Navn)) + } else { + if yysep199 { + r.EncodeMapEntrySeparator() + } + r.EncodeString(codecSelferC_UTF81474, string("Navn")) + if yysep199 { + r.EncodeMapKVSeparator() + } + r.EncodeString(codecSelferC_UTF81474, string(x.Navn)) + } + if yysep199 { + if yyr199 || z.EncBasicHandle().StructToArray { + r.EncodeArrayEnd() + } else { + r.EncodeMapEnd() + } + } + } +} + +func (x *Politikreds) CodecDecodeSelf(d *codec1978.Decoder) { + var h codecSelfer1474 + z, r := codec1978.GenHelperDecoder(d) + _, _, _ = h, z, r + if r.IsContainerType(codecSelverValueTypeMap1474) { + yyl203 := r.ReadMapStart() + if yyl203 == 0 { + r.ReadMapEnd() + } else { + x.codecDecodeSelfFromMap(yyl203, d) + } + } else if r.IsContainerType(codecSelverValueTypeArray1474) { + yyl203 := r.ReadArrayStart() + if yyl203 == 0 { + r.ReadArrayEnd() + } else { + x.codecDecodeSelfFromArray(yyl203, d) + } + } else { + panic(codecSelferOnlyMapOrArrayEncodeToStructErr1474) + } +} + +func (x *Politikreds) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) { + var h codecSelfer1474 + z, r := codec1978.GenHelperDecoder(d) + _, _, _ = h, z, r + var yys204Slc = z.DecScratchBuffer() // default slice to decode into + _ = yys204Slc + var yyhl204 bool = l >= 0 + for yyj204 := 0; ; yyj204++ { + if yyhl204 { + if yyj204 >= l { + break + } + } else { + if r.CheckBreak() { + break + } + if yyj204 > 0 { + r.ReadMapEntrySeparator() + } + } + yys204Slc = r.DecodeBytes(yys204Slc, true, true) + yys204 := string(yys204Slc) + if !yyhl204 { + r.ReadMapKVSeparator() + } + switch yys204 { + case "href": + if r.TryDecodeAsNil() { + x.Href = "" + } else { + x.Href = r.DecodeString() + } + case "kode": + if r.TryDecodeAsNil() { + x.Kode = "" + } else { + x.Kode = r.DecodeString() + } + case "navn": + if r.TryDecodeAsNil() { + x.Navn = "" + } else { + x.Navn = r.DecodeString() + } + default: + z.DecStructFieldNotFound(-1, yys204) + } // end switch yys204 + } // end for yyj204 + if !yyhl204 { + r.ReadMapEnd() + } +} + +func (x *Politikreds) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { + var h codecSelfer1474 + z, r := codec1978.GenHelperDecoder(d) + _, _, _ = h, z, r + var yyj208 int + var yyb208 bool + var yyhl208 bool = l >= 0 + yyj208++ + if yyhl208 { + yyb208 = yyj208 > l + } else { + yyb208 = r.CheckBreak() + } + if yyb208 { + r.ReadArrayEnd() + return + } + if r.TryDecodeAsNil() { + x.Href = "" + } else { + x.Href = r.DecodeString() + } + yyj208++ + if yyhl208 { + yyb208 = yyj208 > l + } else { + yyb208 = r.CheckBreak() + } + if yyb208 { + r.ReadArrayEnd() + return + } + r.ReadArrayEntrySeparator() + if r.TryDecodeAsNil() { + x.Kode = "" + } else { + x.Kode = r.DecodeString() + } + yyj208++ + if yyhl208 { + yyb208 = yyj208 > l + } else { + yyb208 = r.CheckBreak() + } + if yyb208 { + r.ReadArrayEnd() + return + } + r.ReadArrayEntrySeparator() + if r.TryDecodeAsNil() { + x.Navn = "" + } else { + x.Navn = r.DecodeString() + } + for { + yyj208++ + if yyhl208 { + yyb208 = yyj208 > l + } else { + yyb208 = r.CheckBreak() + } + if yyb208 { + break + } + if yyj208 > 1 { + r.ReadArrayEntrySeparator() + } + z.DecStructFieldNotFound(yyj208-1, "") + } + r.ReadArrayEnd() +} + +func (x *PostnummerRef) CodecEncodeSelf(e *codec1978.Encoder) { + var h codecSelfer1474 + z, r := codec1978.GenHelperEncoder(e) + _, _, _ = h, z, r + if x == nil { + r.EncodeNil() + } else { + yysep212 := !z.EncBinary() + const yyr212 bool = false + var yyq212 [3]bool + if yyr212 || z.EncBasicHandle().StructToArray { + r.EncodeArrayStart(3) + } else { + var yynn212 int = 3 + for _, b := range yyq212 { + if b { + yynn212++ + } + } + r.EncodeMapStart(yynn212) + } + if yyr212 || z.EncBasicHandle().StructToArray { + r.EncodeString(codecSelferC_UTF81474, string(x.Href)) + } else { + r.EncodeString(codecSelferC_UTF81474, string("Href")) + if yysep212 { + r.EncodeMapKVSeparator() + } + r.EncodeString(codecSelferC_UTF81474, string(x.Href)) + } + if yyr212 || z.EncBasicHandle().StructToArray { + if yysep212 { + r.EncodeArrayEntrySeparator() + } + r.EncodeString(codecSelferC_UTF81474, string(x.Navn)) + } else { + if yysep212 { + r.EncodeMapEntrySeparator() + } + r.EncodeString(codecSelferC_UTF81474, string("Navn")) + if yysep212 { + r.EncodeMapKVSeparator() + } + r.EncodeString(codecSelferC_UTF81474, string(x.Navn)) + } + if yyr212 || z.EncBasicHandle().StructToArray { + if yysep212 { + r.EncodeArrayEntrySeparator() + } + r.EncodeString(codecSelferC_UTF81474, string(x.Nr)) + } else { + if yysep212 { + r.EncodeMapEntrySeparator() + } + r.EncodeString(codecSelferC_UTF81474, string("Nr")) + if yysep212 { + r.EncodeMapKVSeparator() + } + r.EncodeString(codecSelferC_UTF81474, string(x.Nr)) + } + if yysep212 { + if yyr212 || z.EncBasicHandle().StructToArray { + r.EncodeArrayEnd() + } else { + r.EncodeMapEnd() + } + } + } +} + +func (x *PostnummerRef) CodecDecodeSelf(d *codec1978.Decoder) { + var h codecSelfer1474 + z, r := codec1978.GenHelperDecoder(d) + _, _, _ = h, z, r + if r.IsContainerType(codecSelverValueTypeMap1474) { + yyl216 := r.ReadMapStart() + if yyl216 == 0 { + r.ReadMapEnd() + } else { + x.codecDecodeSelfFromMap(yyl216, d) + } + } else if r.IsContainerType(codecSelverValueTypeArray1474) { + yyl216 := r.ReadArrayStart() + if yyl216 == 0 { + r.ReadArrayEnd() + } else { + x.codecDecodeSelfFromArray(yyl216, d) + } + } else { + panic(codecSelferOnlyMapOrArrayEncodeToStructErr1474) + } +} + +func (x *PostnummerRef) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) { + var h codecSelfer1474 + z, r := codec1978.GenHelperDecoder(d) + _, _, _ = h, z, r + var yys217Slc = z.DecScratchBuffer() // default slice to decode into + _ = yys217Slc + var yyhl217 bool = l >= 0 + for yyj217 := 0; ; yyj217++ { + if yyhl217 { + if yyj217 >= l { + break + } + } else { + if r.CheckBreak() { + break + } + if yyj217 > 0 { + r.ReadMapEntrySeparator() + } + } + yys217Slc = r.DecodeBytes(yys217Slc, true, true) + yys217 := string(yys217Slc) + if !yyhl217 { + r.ReadMapKVSeparator() + } + switch yys217 { + case "href": + if r.TryDecodeAsNil() { + x.Href = "" + } else { + x.Href = r.DecodeString() + } + case "navn": + if r.TryDecodeAsNil() { + x.Navn = "" + } else { + x.Navn = r.DecodeString() + } + case "nr": + if r.TryDecodeAsNil() { + x.Nr = "" + } else { + x.Nr = r.DecodeString() + } + default: + z.DecStructFieldNotFound(-1, yys217) + } // end switch yys217 + } // end for yyj217 + if !yyhl217 { + r.ReadMapEnd() + } +} + +func (x *PostnummerRef) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { + var h codecSelfer1474 + z, r := codec1978.GenHelperDecoder(d) + _, _, _ = h, z, r + var yyj221 int + var yyb221 bool + var yyhl221 bool = l >= 0 + yyj221++ + if yyhl221 { + yyb221 = yyj221 > l + } else { + yyb221 = r.CheckBreak() + } + if yyb221 { + r.ReadArrayEnd() + return + } + if r.TryDecodeAsNil() { + x.Href = "" + } else { + x.Href = r.DecodeString() + } + yyj221++ + if yyhl221 { + yyb221 = yyj221 > l + } else { + yyb221 = r.CheckBreak() + } + if yyb221 { + r.ReadArrayEnd() + return + } + r.ReadArrayEntrySeparator() + if r.TryDecodeAsNil() { + x.Navn = "" + } else { + x.Navn = r.DecodeString() + } + yyj221++ + if yyhl221 { + yyb221 = yyj221 > l + } else { + yyb221 = r.CheckBreak() + } + if yyb221 { + r.ReadArrayEnd() + return + } + r.ReadArrayEntrySeparator() + if r.TryDecodeAsNil() { + x.Nr = "" + } else { + x.Nr = r.DecodeString() + } + for { + yyj221++ + if yyhl221 { + yyb221 = yyj221 > l + } else { + yyb221 = r.CheckBreak() + } + if yyb221 { + break + } + if yyj221 > 1 { + r.ReadArrayEntrySeparator() + } + z.DecStructFieldNotFound(yyj221-1, "") + } + r.ReadArrayEnd() +} + +func (x *Region) CodecEncodeSelf(e *codec1978.Encoder) { + var h codecSelfer1474 + z, r := codec1978.GenHelperEncoder(e) + _, _, _ = h, z, r + if x == nil { + r.EncodeNil() + } else { + yysep225 := !z.EncBinary() + const yyr225 bool = false + var yyq225 [3]bool + if yyr225 || z.EncBasicHandle().StructToArray { + r.EncodeArrayStart(3) + } else { + var yynn225 int = 3 + for _, b := range yyq225 { + if b { + yynn225++ + } + } + r.EncodeMapStart(yynn225) + } + if yyr225 || z.EncBasicHandle().StructToArray { + r.EncodeString(codecSelferC_UTF81474, string(x.Href)) + } else { + r.EncodeString(codecSelferC_UTF81474, string("Href")) + if yysep225 { + r.EncodeMapKVSeparator() + } + r.EncodeString(codecSelferC_UTF81474, string(x.Href)) + } + if yyr225 || z.EncBasicHandle().StructToArray { + if yysep225 { + r.EncodeArrayEntrySeparator() + } + r.EncodeString(codecSelferC_UTF81474, string(x.Kode)) + } else { + if yysep225 { + r.EncodeMapEntrySeparator() + } + r.EncodeString(codecSelferC_UTF81474, string("Kode")) + if yysep225 { + r.EncodeMapKVSeparator() + } + r.EncodeString(codecSelferC_UTF81474, string(x.Kode)) + } + if yyr225 || z.EncBasicHandle().StructToArray { + if yysep225 { + r.EncodeArrayEntrySeparator() + } + r.EncodeString(codecSelferC_UTF81474, string(x.Navn)) + } else { + if yysep225 { + r.EncodeMapEntrySeparator() + } + r.EncodeString(codecSelferC_UTF81474, string("Navn")) + if yysep225 { + r.EncodeMapKVSeparator() + } + r.EncodeString(codecSelferC_UTF81474, string(x.Navn)) + } + if yysep225 { + if yyr225 || z.EncBasicHandle().StructToArray { + r.EncodeArrayEnd() + } else { + r.EncodeMapEnd() + } + } + } +} + +func (x *Region) CodecDecodeSelf(d *codec1978.Decoder) { + var h codecSelfer1474 + z, r := codec1978.GenHelperDecoder(d) + _, _, _ = h, z, r + if r.IsContainerType(codecSelverValueTypeMap1474) { + yyl229 := r.ReadMapStart() + if yyl229 == 0 { + r.ReadMapEnd() + } else { + x.codecDecodeSelfFromMap(yyl229, d) + } + } else if r.IsContainerType(codecSelverValueTypeArray1474) { + yyl229 := r.ReadArrayStart() + if yyl229 == 0 { + r.ReadArrayEnd() + } else { + x.codecDecodeSelfFromArray(yyl229, d) + } + } else { + panic(codecSelferOnlyMapOrArrayEncodeToStructErr1474) + } +} + +func (x *Region) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) { + var h codecSelfer1474 + z, r := codec1978.GenHelperDecoder(d) + _, _, _ = h, z, r + var yys230Slc = z.DecScratchBuffer() // default slice to decode into + _ = yys230Slc + var yyhl230 bool = l >= 0 + for yyj230 := 0; ; yyj230++ { + if yyhl230 { + if yyj230 >= l { + break + } + } else { + if r.CheckBreak() { + break + } + if yyj230 > 0 { + r.ReadMapEntrySeparator() + } + } + yys230Slc = r.DecodeBytes(yys230Slc, true, true) + yys230 := string(yys230Slc) + if !yyhl230 { + r.ReadMapKVSeparator() + } + switch yys230 { + case "href": + if r.TryDecodeAsNil() { + x.Href = "" + } else { + x.Href = r.DecodeString() + } + case "kode": + if r.TryDecodeAsNil() { + x.Kode = "" + } else { + x.Kode = r.DecodeString() + } + case "navn": + if r.TryDecodeAsNil() { + x.Navn = "" + } else { + x.Navn = r.DecodeString() + } + default: + z.DecStructFieldNotFound(-1, yys230) + } // end switch yys230 + } // end for yyj230 + if !yyhl230 { + r.ReadMapEnd() + } +} + +func (x *Region) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { + var h codecSelfer1474 + z, r := codec1978.GenHelperDecoder(d) + _, _, _ = h, z, r + var yyj234 int + var yyb234 bool + var yyhl234 bool = l >= 0 + yyj234++ + if yyhl234 { + yyb234 = yyj234 > l + } else { + yyb234 = r.CheckBreak() + } + if yyb234 { + r.ReadArrayEnd() + return + } + if r.TryDecodeAsNil() { + x.Href = "" + } else { + x.Href = r.DecodeString() + } + yyj234++ + if yyhl234 { + yyb234 = yyj234 > l + } else { + yyb234 = r.CheckBreak() + } + if yyb234 { + r.ReadArrayEnd() + return + } + r.ReadArrayEntrySeparator() + if r.TryDecodeAsNil() { + x.Kode = "" + } else { + x.Kode = r.DecodeString() + } + yyj234++ + if yyhl234 { + yyb234 = yyj234 > l + } else { + yyb234 = r.CheckBreak() + } + if yyb234 { + r.ReadArrayEnd() + return + } + r.ReadArrayEntrySeparator() + if r.TryDecodeAsNil() { + x.Navn = "" + } else { + x.Navn = r.DecodeString() + } + for { + yyj234++ + if yyhl234 { + yyb234 = yyj234 > l + } else { + yyb234 = r.CheckBreak() + } + if yyb234 { + break + } + if yyj234 > 1 { + r.ReadArrayEntrySeparator() + } + z.DecStructFieldNotFound(yyj234-1, "") + } + r.ReadArrayEnd() +} + +func (x *Retskreds) CodecEncodeSelf(e *codec1978.Encoder) { + var h codecSelfer1474 + z, r := codec1978.GenHelperEncoder(e) + _, _, _ = h, z, r + if x == nil { + r.EncodeNil() + } else { + yysep238 := !z.EncBinary() + const yyr238 bool = false + var yyq238 [3]bool + if yyr238 || z.EncBasicHandle().StructToArray { + r.EncodeArrayStart(3) + } else { + var yynn238 int = 3 + for _, b := range yyq238 { + if b { + yynn238++ + } + } + r.EncodeMapStart(yynn238) + } + if yyr238 || z.EncBasicHandle().StructToArray { + r.EncodeString(codecSelferC_UTF81474, string(x.Href)) + } else { + r.EncodeString(codecSelferC_UTF81474, string("Href")) + if yysep238 { + r.EncodeMapKVSeparator() + } + r.EncodeString(codecSelferC_UTF81474, string(x.Href)) + } + if yyr238 || z.EncBasicHandle().StructToArray { + if yysep238 { + r.EncodeArrayEntrySeparator() + } + r.EncodeString(codecSelferC_UTF81474, string(x.Kode)) + } else { + if yysep238 { + r.EncodeMapEntrySeparator() + } + r.EncodeString(codecSelferC_UTF81474, string("Kode")) + if yysep238 { + r.EncodeMapKVSeparator() + } + r.EncodeString(codecSelferC_UTF81474, string(x.Kode)) + } + if yyr238 || z.EncBasicHandle().StructToArray { + if yysep238 { + r.EncodeArrayEntrySeparator() + } + r.EncodeString(codecSelferC_UTF81474, string(x.Navn)) + } else { + if yysep238 { + r.EncodeMapEntrySeparator() + } + r.EncodeString(codecSelferC_UTF81474, string("Navn")) + if yysep238 { + r.EncodeMapKVSeparator() + } + r.EncodeString(codecSelferC_UTF81474, string(x.Navn)) + } + if yysep238 { + if yyr238 || z.EncBasicHandle().StructToArray { + r.EncodeArrayEnd() + } else { + r.EncodeMapEnd() + } + } + } +} + +func (x *Retskreds) CodecDecodeSelf(d *codec1978.Decoder) { + var h codecSelfer1474 + z, r := codec1978.GenHelperDecoder(d) + _, _, _ = h, z, r + if r.IsContainerType(codecSelverValueTypeMap1474) { + yyl242 := r.ReadMapStart() + if yyl242 == 0 { + r.ReadMapEnd() + } else { + x.codecDecodeSelfFromMap(yyl242, d) + } + } else if r.IsContainerType(codecSelverValueTypeArray1474) { + yyl242 := r.ReadArrayStart() + if yyl242 == 0 { + r.ReadArrayEnd() + } else { + x.codecDecodeSelfFromArray(yyl242, d) + } + } else { + panic(codecSelferOnlyMapOrArrayEncodeToStructErr1474) + } +} + +func (x *Retskreds) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) { + var h codecSelfer1474 + z, r := codec1978.GenHelperDecoder(d) + _, _, _ = h, z, r + var yys243Slc = z.DecScratchBuffer() // default slice to decode into + _ = yys243Slc + var yyhl243 bool = l >= 0 + for yyj243 := 0; ; yyj243++ { + if yyhl243 { + if yyj243 >= l { + break + } + } else { + if r.CheckBreak() { + break + } + if yyj243 > 0 { + r.ReadMapEntrySeparator() + } + } + yys243Slc = r.DecodeBytes(yys243Slc, true, true) + yys243 := string(yys243Slc) + if !yyhl243 { + r.ReadMapKVSeparator() + } + switch yys243 { + case "href": + if r.TryDecodeAsNil() { + x.Href = "" + } else { + x.Href = r.DecodeString() + } + case "kode": + if r.TryDecodeAsNil() { + x.Kode = "" + } else { + x.Kode = r.DecodeString() + } + case "navn": + if r.TryDecodeAsNil() { + x.Navn = "" + } else { + x.Navn = r.DecodeString() + } + default: + z.DecStructFieldNotFound(-1, yys243) + } // end switch yys243 + } // end for yyj243 + if !yyhl243 { + r.ReadMapEnd() + } +} + +func (x *Retskreds) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { + var h codecSelfer1474 + z, r := codec1978.GenHelperDecoder(d) + _, _, _ = h, z, r + var yyj247 int + var yyb247 bool + var yyhl247 bool = l >= 0 + yyj247++ + if yyhl247 { + yyb247 = yyj247 > l + } else { + yyb247 = r.CheckBreak() + } + if yyb247 { + r.ReadArrayEnd() + return + } + if r.TryDecodeAsNil() { + x.Href = "" + } else { + x.Href = r.DecodeString() + } + yyj247++ + if yyhl247 { + yyb247 = yyj247 > l + } else { + yyb247 = r.CheckBreak() + } + if yyb247 { + r.ReadArrayEnd() + return + } + r.ReadArrayEntrySeparator() + if r.TryDecodeAsNil() { + x.Kode = "" + } else { + x.Kode = r.DecodeString() + } + yyj247++ + if yyhl247 { + yyb247 = yyj247 > l + } else { + yyb247 = r.CheckBreak() + } + if yyb247 { + r.ReadArrayEnd() + return + } + r.ReadArrayEntrySeparator() + if r.TryDecodeAsNil() { + x.Navn = "" + } else { + x.Navn = r.DecodeString() + } + for { + yyj247++ + if yyhl247 { + yyb247 = yyj247 > l + } else { + yyb247 = r.CheckBreak() + } + if yyb247 { + break + } + if yyj247 > 1 { + r.ReadArrayEntrySeparator() + } + z.DecStructFieldNotFound(yyj247-1, "") + } + r.ReadArrayEnd() +} + +func (x *Sogn) CodecEncodeSelf(e *codec1978.Encoder) { + var h codecSelfer1474 + z, r := codec1978.GenHelperEncoder(e) + _, _, _ = h, z, r + if x == nil { + r.EncodeNil() + } else { + yysep251 := !z.EncBinary() + const yyr251 bool = false + var yyq251 [3]bool + if yyr251 || z.EncBasicHandle().StructToArray { + r.EncodeArrayStart(3) + } else { + var yynn251 int = 3 + for _, b := range yyq251 { + if b { + yynn251++ + } + } + r.EncodeMapStart(yynn251) + } + if yyr251 || z.EncBasicHandle().StructToArray { + r.EncodeString(codecSelferC_UTF81474, string(x.Href)) + } else { + r.EncodeString(codecSelferC_UTF81474, string("Href")) + if yysep251 { + r.EncodeMapKVSeparator() + } + r.EncodeString(codecSelferC_UTF81474, string(x.Href)) + } + if yyr251 || z.EncBasicHandle().StructToArray { + if yysep251 { + r.EncodeArrayEntrySeparator() + } + r.EncodeString(codecSelferC_UTF81474, string(x.Kode)) + } else { + if yysep251 { + r.EncodeMapEntrySeparator() + } + r.EncodeString(codecSelferC_UTF81474, string("Kode")) + if yysep251 { + r.EncodeMapKVSeparator() + } + r.EncodeString(codecSelferC_UTF81474, string(x.Kode)) + } + if yyr251 || z.EncBasicHandle().StructToArray { + if yysep251 { + r.EncodeArrayEntrySeparator() + } + r.EncodeString(codecSelferC_UTF81474, string(x.Navn)) + } else { + if yysep251 { + r.EncodeMapEntrySeparator() + } + r.EncodeString(codecSelferC_UTF81474, string("Navn")) + if yysep251 { + r.EncodeMapKVSeparator() + } + r.EncodeString(codecSelferC_UTF81474, string(x.Navn)) + } + if yysep251 { + if yyr251 || z.EncBasicHandle().StructToArray { + r.EncodeArrayEnd() + } else { + r.EncodeMapEnd() + } + } + } +} + +func (x *Sogn) CodecDecodeSelf(d *codec1978.Decoder) { + var h codecSelfer1474 + z, r := codec1978.GenHelperDecoder(d) + _, _, _ = h, z, r + if r.IsContainerType(codecSelverValueTypeMap1474) { + yyl255 := r.ReadMapStart() + if yyl255 == 0 { + r.ReadMapEnd() + } else { + x.codecDecodeSelfFromMap(yyl255, d) + } + } else if r.IsContainerType(codecSelverValueTypeArray1474) { + yyl255 := r.ReadArrayStart() + if yyl255 == 0 { + r.ReadArrayEnd() + } else { + x.codecDecodeSelfFromArray(yyl255, d) + } + } else { + panic(codecSelferOnlyMapOrArrayEncodeToStructErr1474) + } +} + +func (x *Sogn) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) { + var h codecSelfer1474 + z, r := codec1978.GenHelperDecoder(d) + _, _, _ = h, z, r + var yys256Slc = z.DecScratchBuffer() // default slice to decode into + _ = yys256Slc + var yyhl256 bool = l >= 0 + for yyj256 := 0; ; yyj256++ { + if yyhl256 { + if yyj256 >= l { + break + } + } else { + if r.CheckBreak() { + break + } + if yyj256 > 0 { + r.ReadMapEntrySeparator() + } + } + yys256Slc = r.DecodeBytes(yys256Slc, true, true) + yys256 := string(yys256Slc) + if !yyhl256 { + r.ReadMapKVSeparator() + } + switch yys256 { + case "href": + if r.TryDecodeAsNil() { + x.Href = "" + } else { + x.Href = r.DecodeString() + } + case "kode": + if r.TryDecodeAsNil() { + x.Kode = "" + } else { + x.Kode = r.DecodeString() + } + case "navn": + if r.TryDecodeAsNil() { + x.Navn = "" + } else { + x.Navn = r.DecodeString() + } + default: + z.DecStructFieldNotFound(-1, yys256) + } // end switch yys256 + } // end for yyj256 + if !yyhl256 { + r.ReadMapEnd() + } +} + +func (x *Sogn) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { + var h codecSelfer1474 + z, r := codec1978.GenHelperDecoder(d) + _, _, _ = h, z, r + var yyj260 int + var yyb260 bool + var yyhl260 bool = l >= 0 + yyj260++ + if yyhl260 { + yyb260 = yyj260 > l + } else { + yyb260 = r.CheckBreak() + } + if yyb260 { + r.ReadArrayEnd() + return + } + if r.TryDecodeAsNil() { + x.Href = "" + } else { + x.Href = r.DecodeString() + } + yyj260++ + if yyhl260 { + yyb260 = yyj260 > l + } else { + yyb260 = r.CheckBreak() + } + if yyb260 { + r.ReadArrayEnd() + return + } + r.ReadArrayEntrySeparator() + if r.TryDecodeAsNil() { + x.Kode = "" + } else { + x.Kode = r.DecodeString() + } + yyj260++ + if yyhl260 { + yyb260 = yyj260 > l + } else { + yyb260 = r.CheckBreak() + } + if yyb260 { + r.ReadArrayEnd() + return + } + r.ReadArrayEntrySeparator() + if r.TryDecodeAsNil() { + x.Navn = "" + } else { + x.Navn = r.DecodeString() + } + for { + yyj260++ + if yyhl260 { + yyb260 = yyj260 > l + } else { + yyb260 = r.CheckBreak() + } + if yyb260 { + break + } + if yyj260 > 1 { + r.ReadArrayEntrySeparator() + } + z.DecStructFieldNotFound(yyj260-1, "") + } + r.ReadArrayEnd() +} + +func (x *VejstykkeRef) CodecEncodeSelf(e *codec1978.Encoder) { + var h codecSelfer1474 + z, r := codec1978.GenHelperEncoder(e) + _, _, _ = h, z, r + if x == nil { + r.EncodeNil() + } else { + yysep264 := !z.EncBinary() + const yyr264 bool = false + var yyq264 [3]bool + if yyr264 || z.EncBasicHandle().StructToArray { + r.EncodeArrayStart(3) + } else { + var yynn264 int = 3 + for _, b := range yyq264 { + if b { + yynn264++ + } + } + r.EncodeMapStart(yynn264) + } + if yyr264 || z.EncBasicHandle().StructToArray { + r.EncodeString(codecSelferC_UTF81474, string(x.Href)) + } else { + r.EncodeString(codecSelferC_UTF81474, string("Href")) + if yysep264 { + r.EncodeMapKVSeparator() + } + r.EncodeString(codecSelferC_UTF81474, string(x.Href)) + } + if yyr264 || z.EncBasicHandle().StructToArray { + if yysep264 { + r.EncodeArrayEntrySeparator() + } + r.EncodeString(codecSelferC_UTF81474, string(x.Kode)) + } else { + if yysep264 { + r.EncodeMapEntrySeparator() + } + r.EncodeString(codecSelferC_UTF81474, string("Kode")) + if yysep264 { + r.EncodeMapKVSeparator() + } + r.EncodeString(codecSelferC_UTF81474, string(x.Kode)) + } + if yyr264 || z.EncBasicHandle().StructToArray { + if yysep264 { + r.EncodeArrayEntrySeparator() + } + r.EncodeString(codecSelferC_UTF81474, string(x.Navn)) + } else { + if yysep264 { + r.EncodeMapEntrySeparator() + } + r.EncodeString(codecSelferC_UTF81474, string("Navn")) + if yysep264 { + r.EncodeMapKVSeparator() + } + r.EncodeString(codecSelferC_UTF81474, string(x.Navn)) + } + if yysep264 { + if yyr264 || z.EncBasicHandle().StructToArray { + r.EncodeArrayEnd() + } else { + r.EncodeMapEnd() + } + } + } +} + +func (x *VejstykkeRef) CodecDecodeSelf(d *codec1978.Decoder) { + var h codecSelfer1474 + z, r := codec1978.GenHelperDecoder(d) + _, _, _ = h, z, r + if r.IsContainerType(codecSelverValueTypeMap1474) { + yyl268 := r.ReadMapStart() + if yyl268 == 0 { + r.ReadMapEnd() + } else { + x.codecDecodeSelfFromMap(yyl268, d) + } + } else if r.IsContainerType(codecSelverValueTypeArray1474) { + yyl268 := r.ReadArrayStart() + if yyl268 == 0 { + r.ReadArrayEnd() + } else { + x.codecDecodeSelfFromArray(yyl268, d) + } + } else { + panic(codecSelferOnlyMapOrArrayEncodeToStructErr1474) + } +} + +func (x *VejstykkeRef) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) { + var h codecSelfer1474 + z, r := codec1978.GenHelperDecoder(d) + _, _, _ = h, z, r + var yys269Slc = z.DecScratchBuffer() // default slice to decode into + _ = yys269Slc + var yyhl269 bool = l >= 0 + for yyj269 := 0; ; yyj269++ { + if yyhl269 { + if yyj269 >= l { + break + } + } else { + if r.CheckBreak() { + break + } + if yyj269 > 0 { + r.ReadMapEntrySeparator() + } + } + yys269Slc = r.DecodeBytes(yys269Slc, true, true) + yys269 := string(yys269Slc) + if !yyhl269 { + r.ReadMapKVSeparator() + } + switch yys269 { + case "href": + if r.TryDecodeAsNil() { + x.Href = "" + } else { + x.Href = r.DecodeString() + } + case "kode": + if r.TryDecodeAsNil() { + x.Kode = "" + } else { + x.Kode = r.DecodeString() + } + case "navn": + if r.TryDecodeAsNil() { + x.Navn = "" + } else { + x.Navn = r.DecodeString() + } + default: + z.DecStructFieldNotFound(-1, yys269) + } // end switch yys269 + } // end for yyj269 + if !yyhl269 { + r.ReadMapEnd() + } +} + +func (x *VejstykkeRef) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { + var h codecSelfer1474 + z, r := codec1978.GenHelperDecoder(d) + _, _, _ = h, z, r + var yyj273 int + var yyb273 bool + var yyhl273 bool = l >= 0 + yyj273++ + if yyhl273 { + yyb273 = yyj273 > l + } else { + yyb273 = r.CheckBreak() + } + if yyb273 { + r.ReadArrayEnd() + return + } + if r.TryDecodeAsNil() { + x.Href = "" + } else { + x.Href = r.DecodeString() + } + yyj273++ + if yyhl273 { + yyb273 = yyj273 > l + } else { + yyb273 = r.CheckBreak() + } + if yyb273 { + r.ReadArrayEnd() + return + } + r.ReadArrayEntrySeparator() + if r.TryDecodeAsNil() { + x.Kode = "" + } else { + x.Kode = r.DecodeString() + } + yyj273++ + if yyhl273 { + yyb273 = yyj273 > l + } else { + yyb273 = r.CheckBreak() + } + if yyb273 { + r.ReadArrayEnd() + return + } + r.ReadArrayEntrySeparator() + if r.TryDecodeAsNil() { + x.Navn = "" + } else { + x.Navn = r.DecodeString() + } + for { + yyj273++ + if yyhl273 { + yyb273 = yyj273 > l + } else { + yyb273 = r.CheckBreak() + } + if yyb273 { + break + } + if yyj273 > 1 { + r.ReadArrayEntrySeparator() + } + z.DecStructFieldNotFound(yyj273-1, "") + } + r.ReadArrayEnd() +} + +func (x *Vejstykke) CodecEncodeSelf(e *codec1978.Encoder) { + var h codecSelfer1474 + z, r := codec1978.GenHelperEncoder(e) + _, _, _ = h, z, r + if x == nil { + r.EncodeNil() + } else { + yysep277 := !z.EncBinary() + const yyr277 bool = false + var yyq277 [7]bool + if yyr277 || z.EncBasicHandle().StructToArray { + r.EncodeArrayStart(7) + } else { + var yynn277 int = 7 + for _, b := range yyq277 { + if b { + yynn277++ + } + } + r.EncodeMapStart(yynn277) + } + if yyr277 || z.EncBasicHandle().StructToArray { + r.EncodeString(codecSelferC_UTF81474, string(x.Adresseringsnavn)) + } else { + r.EncodeString(codecSelferC_UTF81474, string("Adresseringsnavn")) + if yysep277 { + r.EncodeMapKVSeparator() + } + r.EncodeString(codecSelferC_UTF81474, string(x.Adresseringsnavn)) + } + if yyr277 || z.EncBasicHandle().StructToArray { + if yysep277 { + r.EncodeArrayEntrySeparator() + } + x.Historik.CodecEncodeSelf(e) + } else { + if yysep277 { + r.EncodeMapEntrySeparator() + } + r.EncodeString(codecSelferC_UTF81474, string("Historik")) + if yysep277 { + r.EncodeMapKVSeparator() + } + x.Historik.CodecEncodeSelf(e) + } + if yyr277 || z.EncBasicHandle().StructToArray { + if yysep277 { + r.EncodeArrayEntrySeparator() + } + r.EncodeString(codecSelferC_UTF81474, string(x.Href)) + } else { + if yysep277 { + r.EncodeMapEntrySeparator() + } + r.EncodeString(codecSelferC_UTF81474, string("Href")) + if yysep277 { + r.EncodeMapKVSeparator() + } + r.EncodeString(codecSelferC_UTF81474, string(x.Href)) + } + if yyr277 || z.EncBasicHandle().StructToArray { + if yysep277 { + r.EncodeArrayEntrySeparator() + } + r.EncodeString(codecSelferC_UTF81474, string(x.Kode)) + } else { + if yysep277 { + r.EncodeMapEntrySeparator() + } + r.EncodeString(codecSelferC_UTF81474, string("Kode")) + if yysep277 { + r.EncodeMapKVSeparator() + } + r.EncodeString(codecSelferC_UTF81474, string(x.Kode)) + } + if yyr277 || z.EncBasicHandle().StructToArray { + if yysep277 { + r.EncodeArrayEntrySeparator() + } + x.Kommune.CodecEncodeSelf(e) + } else { + if yysep277 { + r.EncodeMapEntrySeparator() + } + r.EncodeString(codecSelferC_UTF81474, string("Kommune")) + if yysep277 { + r.EncodeMapKVSeparator() + } + x.Kommune.CodecEncodeSelf(e) + } + if yyr277 || z.EncBasicHandle().StructToArray { + if yysep277 { + r.EncodeArrayEntrySeparator() + } + r.EncodeString(codecSelferC_UTF81474, string(x.Navn)) + } else { + if yysep277 { + r.EncodeMapEntrySeparator() + } + r.EncodeString(codecSelferC_UTF81474, string("Navn")) + if yysep277 { + r.EncodeMapKVSeparator() + } + r.EncodeString(codecSelferC_UTF81474, string(x.Navn)) + } + if yyr277 || z.EncBasicHandle().StructToArray { + if yysep277 { + r.EncodeArrayEntrySeparator() + } + if x.Postnumre == nil { + r.EncodeNil() + } else { + h.encSlicePostnummerRef([]PostnummerRef(x.Postnumre), e) + } + } else { + if yysep277 { + r.EncodeMapEntrySeparator() + } + r.EncodeString(codecSelferC_UTF81474, string("Postnumre")) + if yysep277 { + r.EncodeMapKVSeparator() + } + if x.Postnumre == nil { + r.EncodeNil() + } else { + h.encSlicePostnummerRef([]PostnummerRef(x.Postnumre), e) + } + } + if yysep277 { + if yyr277 || z.EncBasicHandle().StructToArray { + r.EncodeArrayEnd() + } else { + r.EncodeMapEnd() + } + } + } +} + +func (x *Vejstykke) CodecDecodeSelf(d *codec1978.Decoder) { + var h codecSelfer1474 + z, r := codec1978.GenHelperDecoder(d) + _, _, _ = h, z, r + if r.IsContainerType(codecSelverValueTypeMap1474) { + yyl285 := r.ReadMapStart() + if yyl285 == 0 { + r.ReadMapEnd() + } else { + x.codecDecodeSelfFromMap(yyl285, d) + } + } else if r.IsContainerType(codecSelverValueTypeArray1474) { + yyl285 := r.ReadArrayStart() + if yyl285 == 0 { + r.ReadArrayEnd() + } else { + x.codecDecodeSelfFromArray(yyl285, d) + } + } else { + panic(codecSelferOnlyMapOrArrayEncodeToStructErr1474) + } +} + +func (x *Vejstykke) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) { + var h codecSelfer1474 + z, r := codec1978.GenHelperDecoder(d) + _, _, _ = h, z, r + var yys286Slc = z.DecScratchBuffer() // default slice to decode into + _ = yys286Slc + var yyhl286 bool = l >= 0 + for yyj286 := 0; ; yyj286++ { + if yyhl286 { + if yyj286 >= l { + break + } + } else { + if r.CheckBreak() { + break + } + if yyj286 > 0 { + r.ReadMapEntrySeparator() + } + } + yys286Slc = r.DecodeBytes(yys286Slc, true, true) + yys286 := string(yys286Slc) + if !yyhl286 { + r.ReadMapKVSeparator() + } + switch yys286 { + case "adresseringsnavn": + if r.TryDecodeAsNil() { + x.Adresseringsnavn = "" + } else { + x.Adresseringsnavn = r.DecodeString() + } + case "historik": + if r.TryDecodeAsNil() { + x.Historik = Historik{} + } else { + yyv288 := &x.Historik + yyv288.CodecDecodeSelf(d) + } + case "href": + if r.TryDecodeAsNil() { + x.Href = "" + } else { + x.Href = r.DecodeString() + } + case "kode": + if r.TryDecodeAsNil() { + x.Kode = "" + } else { + x.Kode = r.DecodeString() + } + case "kommune": + if r.TryDecodeAsNil() { + x.Kommune = Kommune{} + } else { + yyv291 := &x.Kommune + yyv291.CodecDecodeSelf(d) + } + case "navn": + if r.TryDecodeAsNil() { + x.Navn = "" + } else { + x.Navn = r.DecodeString() + } + case "postnumre": + if r.TryDecodeAsNil() { + x.Postnumre = nil + } else { + yyv293 := &x.Postnumre + h.decSlicePostnummerRef((*[]PostnummerRef)(yyv293), d) + } + default: + z.DecStructFieldNotFound(-1, yys286) + } // end switch yys286 + } // end for yyj286 + if !yyhl286 { + r.ReadMapEnd() + } +} + +func (x *Vejstykke) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) { + var h codecSelfer1474 + z, r := codec1978.GenHelperDecoder(d) + _, _, _ = h, z, r + var yyj294 int + var yyb294 bool + var yyhl294 bool = l >= 0 + yyj294++ + if yyhl294 { + yyb294 = yyj294 > l + } else { + yyb294 = r.CheckBreak() + } + if yyb294 { + r.ReadArrayEnd() + return + } + if r.TryDecodeAsNil() { + x.Adresseringsnavn = "" + } else { + x.Adresseringsnavn = r.DecodeString() + } + yyj294++ + if yyhl294 { + yyb294 = yyj294 > l + } else { + yyb294 = r.CheckBreak() + } + if yyb294 { + r.ReadArrayEnd() + return + } + r.ReadArrayEntrySeparator() + if r.TryDecodeAsNil() { + x.Historik = Historik{} + } else { + yyv296 := &x.Historik + yyv296.CodecDecodeSelf(d) + } + yyj294++ + if yyhl294 { + yyb294 = yyj294 > l + } else { + yyb294 = r.CheckBreak() + } + if yyb294 { + r.ReadArrayEnd() + return + } + r.ReadArrayEntrySeparator() + if r.TryDecodeAsNil() { + x.Href = "" + } else { + x.Href = r.DecodeString() + } + yyj294++ + if yyhl294 { + yyb294 = yyj294 > l + } else { + yyb294 = r.CheckBreak() + } + if yyb294 { + r.ReadArrayEnd() + return + } + r.ReadArrayEntrySeparator() + if r.TryDecodeAsNil() { + x.Kode = "" + } else { + x.Kode = r.DecodeString() + } + yyj294++ + if yyhl294 { + yyb294 = yyj294 > l + } else { + yyb294 = r.CheckBreak() + } + if yyb294 { + r.ReadArrayEnd() + return + } + r.ReadArrayEntrySeparator() + if r.TryDecodeAsNil() { + x.Kommune = Kommune{} + } else { + yyv299 := &x.Kommune + yyv299.CodecDecodeSelf(d) + } + yyj294++ + if yyhl294 { + yyb294 = yyj294 > l + } else { + yyb294 = r.CheckBreak() + } + if yyb294 { + r.ReadArrayEnd() + return + } + r.ReadArrayEntrySeparator() + if r.TryDecodeAsNil() { + x.Navn = "" + } else { + x.Navn = r.DecodeString() + } + yyj294++ + if yyhl294 { + yyb294 = yyj294 > l + } else { + yyb294 = r.CheckBreak() + } + if yyb294 { + r.ReadArrayEnd() + return + } + r.ReadArrayEntrySeparator() + if r.TryDecodeAsNil() { + x.Postnumre = nil + } else { + yyv301 := &x.Postnumre + h.decSlicePostnummerRef((*[]PostnummerRef)(yyv301), d) + } + for { + yyj294++ + if yyhl294 { + yyb294 = yyj294 > l + } else { + yyb294 = r.CheckBreak() + } + if yyb294 { + break + } + if yyj294 > 1 { + r.ReadArrayEntrySeparator() + } + z.DecStructFieldNotFound(yyj294-1, "") + } + r.ReadArrayEnd() +} + +func (x codecSelfer1474) encSliceKommune(v []Kommune, e *codec1978.Encoder) { + var h codecSelfer1474 + z, r := codec1978.GenHelperEncoder(e) + _, _, _ = h, z, r + r.EncodeArrayStart(len(v)) + yys302 := !z.EncBinary() + if yys302 { + for yyi302, yyv302 := range v { + if yyi302 > 0 { + r.EncodeArrayEntrySeparator() + } + yyv302.CodecEncodeSelf(e) + } + r.EncodeArrayEnd() + } else { + for _, yyv302 := range v { + yyv302.CodecEncodeSelf(e) + } + } +} + +func (x codecSelfer1474) decSliceKommune(v *[]Kommune, d *codec1978.Decoder) { + var h codecSelfer1474 + z, r := codec1978.GenHelperDecoder(d) + _, _, _ = h, z, r + + const yyArr303 bool = false + yyv303 := *v + yyh303, yyl303 := z.DecSliceHelperStart() + + var yyc303 bool + if yyv303 == nil { + if yyl303 <= 0 { + yyv303 = []Kommune{} + } else { + yyv303 = make([]Kommune, yyl303, yyl303) + } + yyc303 = true + } + + if yyl303 == 0 { + if len(yyv303) != 0 { + yyv303 = yyv303[:0] + yyc303 = true + } + } else if yyl303 > 0 { + yyn303 := yyl303 + if yyl303 > cap(yyv303) { + yyv303 = make([]Kommune, yyl303, yyl303) + yyc303 = true + + } else if yyl303 != len(yyv303) { + yyv303 = yyv303[:yyl303] + yyc303 = true + } + yyj303 := 0 + for ; yyj303 < yyn303; yyj303++ { + if r.TryDecodeAsNil() { + yyv303[yyj303] = Kommune{} + } else { + yyv304 := &yyv303[yyj303] + yyv304.CodecDecodeSelf(d) + } + + } + } else { + for yyj303 := 0; !r.CheckBreak(); yyj303++ { + if yyj303 >= len(yyv303) { + yyv303 = append(yyv303, Kommune{}) // var yyz303 Kommune + yyc303 = true + } + if yyj303 > 0 { + yyh303.Sep(yyj303) + } + if yyj303 < len(yyv303) { + if r.TryDecodeAsNil() { + yyv303[yyj303] = Kommune{} + } else { + yyv305 := &yyv303[yyj303] + yyv305.CodecDecodeSelf(d) + } + + } else { + z.DecSwallow() + } + } + yyh303.End() + } + if yyc303 { + *v = yyv303 + } +} + +func (x codecSelfer1474) encSlicePostnummerRef(v []PostnummerRef, e *codec1978.Encoder) { + var h codecSelfer1474 + z, r := codec1978.GenHelperEncoder(e) + _, _, _ = h, z, r + r.EncodeArrayStart(len(v)) + yys306 := !z.EncBinary() + if yys306 { + for yyi306, yyv306 := range v { + if yyi306 > 0 { + r.EncodeArrayEntrySeparator() + } + yyv306.CodecEncodeSelf(e) + } + r.EncodeArrayEnd() + } else { + for _, yyv306 := range v { + yyv306.CodecEncodeSelf(e) + } + } +} + +func (x codecSelfer1474) decSlicePostnummerRef(v *[]PostnummerRef, d *codec1978.Decoder) { + var h codecSelfer1474 + z, r := codec1978.GenHelperDecoder(d) + _, _, _ = h, z, r + + const yyArr307 bool = false + yyv307 := *v + yyh307, yyl307 := z.DecSliceHelperStart() + + var yyc307 bool + if yyv307 == nil { + if yyl307 <= 0 { + yyv307 = []PostnummerRef{} + } else { + yyv307 = make([]PostnummerRef, yyl307, yyl307) + } + yyc307 = true + } + + if yyl307 == 0 { + if len(yyv307) != 0 { + yyv307 = yyv307[:0] + yyc307 = true + } + } else if yyl307 > 0 { + yyn307 := yyl307 + if yyl307 > cap(yyv307) { + yyv307 = make([]PostnummerRef, yyl307, yyl307) + yyc307 = true + + } else if yyl307 != len(yyv307) { + yyv307 = yyv307[:yyl307] + yyc307 = true + } + yyj307 := 0 + for ; yyj307 < yyn307; yyj307++ { + if r.TryDecodeAsNil() { + yyv307[yyj307] = PostnummerRef{} + } else { + yyv308 := &yyv307[yyj307] + yyv308.CodecDecodeSelf(d) + } + + } + } else { + for yyj307 := 0; !r.CheckBreak(); yyj307++ { + if yyj307 >= len(yyv307) { + yyv307 = append(yyv307, PostnummerRef{}) // var yyz307 PostnummerRef + yyc307 = true + } + if yyj307 > 0 { + yyh307.Sep(yyj307) + } + if yyj307 < len(yyv307) { + if r.TryDecodeAsNil() { + yyv307[yyj307] = PostnummerRef{} + } else { + yyv309 := &yyv307[yyj307] + yyv309.CodecDecodeSelf(d) + } + + } else { + z.DecSwallow() + } + } + yyh307.End() + } + if yyc307 { + *v = yyv307 + } +} diff --git a/vejstykke.go b/vejstykke.go new file mode 100644 index 0000000..cac8b42 --- /dev/null +++ b/vejstykke.go @@ -0,0 +1,16 @@ +package dawa + +// Et vejstykke er en vej, som er afgrænset af en kommune. +// Et vejstykke er identificeret ved en kommunekode og en vejkode og har desuden et navn. +// En vej som gennemløber mere end en kommune vil bestå af flere vejstykker. +// Det er p.t. ikke muligt at få information om hvilke vejstykker der er en del af den samme vej. +// Vejstykker er udstillet under /vejstykker +type Vejstykke struct { + Adresseringsnavn string `json:"adresseringsnavn"` //En evt. forkortet udgave af vejnavnet på højst 20 tegn, som bruges ved adressering på labels og rudekuverter og lign., hvor der ikke plads til det fulde vejnavn. + Historik Historik `json:"historik"` // Væsentlige tidspunkter for vejstykket + Href string `json:"href"` // Vejstykkets unikke URL. + Kode string `json:"kode"` // Identifikation af vejstykke. Er unikt indenfor den pågældende kommune. Repræsenteret ved fire cifre. Eksempel: I Københavns kommune er ”0004” lig ”Abel Cathrines Gade”. + Kommune Kommune `json:"kommune"` // Kommunen som vejstykket er beliggende i. + Navn string `json:"navn"` // Vejens navn som det er fastsat og registreret af kommunen. Repræsenteret ved indtil 40 tegn. Eksempel: ”Hvidkildevej”. + Postnumre []PostnummerRef `json:"postnumre"` // Postnummrene som vejstykket er beliggende i. +}