From 7ff278e0cfb8695cb261d57fd8c43da87b677d27 Mon Sep 17 00:00:00 2001 From: xuu Date: Mon, 3 Mar 2025 22:10:47 -0700 Subject: [PATCH] chore: add flatbuffers support --- Makefile | 10 + example.txt | 2 + go.mod | 3 +- go.sum | 4 + lextwt.avro | 329 ++++++++++++---------- lextwt.fbs | 95 +++++++ main.go | 87 +++++- twt-avro/example.txt | 2 + twt-avro/gen.go | 63 ++++- twt-avro/helper.go | 78 +++++- twt-avro/helper_test.go | 37 ++- twt-fbs/example.txt | 2 + twt-fbs/helper.go | 483 ++++++++++++++++++++++++++++++++ twt-fbs/helper_test.go | 62 ++++ twt-fbs/lextwt/BangMention.go | 71 +++++ twt-fbs/lextwt/Code.go | 75 +++++ twt-fbs/lextwt/CodeType.go | 29 ++ twt-fbs/lextwt/Comment.go | 82 ++++++ twt-fbs/lextwt/DateTime.go | 79 ++++++ twt-fbs/lextwt/Elem.go | 53 ++++ twt-fbs/lextwt/LineSeparator.go | 49 ++++ twt-fbs/lextwt/Link.go | 97 +++++++ twt-fbs/lextwt/LinkType.go | 35 +++ twt-fbs/lextwt/Mention.go | 71 +++++ twt-fbs/lextwt/Msg.go | 76 +++++ twt-fbs/lextwt/Subject.go | 76 +++++ twt-fbs/lextwt/Tag.go | 71 +++++ twt-fbs/lextwt/Text.go | 60 ++++ twt-fbs/lextwt/Twt.go | 107 +++++++ twt-fbs/lextwt/TwtRegistry.go | 127 +++++++++ twt-fbs/lextwt/Twter.go | 71 +++++ 31 files changed, 2321 insertions(+), 165 deletions(-) create mode 100644 Makefile create mode 100644 example.txt create mode 100644 lextwt.fbs create mode 100644 twt-avro/example.txt create mode 100644 twt-fbs/example.txt create mode 100644 twt-fbs/helper.go create mode 100644 twt-fbs/helper_test.go create mode 100644 twt-fbs/lextwt/BangMention.go create mode 100644 twt-fbs/lextwt/Code.go create mode 100644 twt-fbs/lextwt/CodeType.go create mode 100644 twt-fbs/lextwt/Comment.go create mode 100644 twt-fbs/lextwt/DateTime.go create mode 100644 twt-fbs/lextwt/Elem.go create mode 100644 twt-fbs/lextwt/LineSeparator.go create mode 100644 twt-fbs/lextwt/Link.go create mode 100644 twt-fbs/lextwt/LinkType.go create mode 100644 twt-fbs/lextwt/Mention.go create mode 100644 twt-fbs/lextwt/Msg.go create mode 100644 twt-fbs/lextwt/Subject.go create mode 100644 twt-fbs/lextwt/Tag.go create mode 100644 twt-fbs/lextwt/Text.go create mode 100644 twt-fbs/lextwt/Twt.go create mode 100644 twt-fbs/lextwt/TwtRegistry.go create mode 100644 twt-fbs/lextwt/Twter.go diff --git a/Makefile b/Makefile new file mode 100644 index 0000000..ef6e69f --- /dev/null +++ b/Makefile @@ -0,0 +1,10 @@ +avro: twt-avro/gen.go +twt-avro/gen.go: lextwt.avro + go tool avro gen -pkg twt_avro -encoders lextwt.avro > twt-avro/gen.go + + +flatbuffers: twt-fbs/gen.go +twt-fbs/gen.go: lextwt.fbs + flatc -o twt-fbs --go lextwt.fbs + +.ALL: avro flatbuffers \ No newline at end of file diff --git a/example.txt b/example.txt new file mode 100644 index 0000000..8327305 --- /dev/null +++ b/example.txt @@ -0,0 +1,2 @@ +example https://example.org/twtxt.txt 2016-02-06T21:32:02.000Z @erlehmann is messing with timestamps in @buckket #twtxt :) +example https://example.org/twtxt.txt 2016-02-06T12:14:18.000Z Simple nodejs script to convert your twitter timeline to twtxt: https://t.co/txnWsC5jvA ( find my #twtxt at https://t.co/uN1KDXwJ8B ) diff --git a/go.mod b/go.mod index 4efcc32..829d2e1 100644 --- a/go.mod +++ b/go.mod @@ -14,6 +14,7 @@ require github.com/hamba/avro/v2 v2.28.0 require ( github.com/davecgh/go-spew v1.1.1 // indirect github.com/ettle/strcase v0.2.0 // indirect + github.com/google/flatbuffers v25.2.10+incompatible // indirect github.com/hashicorp/errwrap v1.1.0 // indirect github.com/hashicorp/go-multierror v1.1.1 // indirect github.com/pmezard/go-difflib v1.0.0 // indirect @@ -65,7 +66,7 @@ require ( github.com/rivo/uniseg v0.4.7 // indirect github.com/samber/lo v1.49.1 // indirect github.com/stretchr/testify v1.10.0 - go.yarn.social/lextwt v0.1.2 + go.yarn.social/lextwt v0.1.4 golang.org/x/arch v0.14.0 // indirect golang.org/x/exp v0.0.0-20250210185358-939b2ce775ac // indirect golang.org/x/net v0.35.0 // indirect diff --git a/go.sum b/go.sum index 7a5a1d8..cf54a51 100644 --- a/go.sum +++ b/go.sum @@ -38,6 +38,8 @@ github.com/go-delve/delve v1.24.0/go.mod h1:yNWXOuo4yslMOOj7O8gIRrf/trDBrFy5ZXwJ github.com/go-json-experiment/json v0.0.0-20250213060926-925ba3f173fa h1:Rpu6sKAzIeSWBkrFHD52g8yipagcPbY2Lmm70NL1Gzc= github.com/go-json-experiment/json v0.0.0-20250213060926-925ba3f173fa/go.mod h1:TiCD2a1pcmjd7YnhGH0f/zKNcCD06B029pHhzV23c2M= github.com/golang/snappy v0.0.4/go.mod h1:/XxbfmMg8lxefKM7IXC3fBNl/7bRcc72aCRzEWrmP2Q= +github.com/google/flatbuffers v25.2.10+incompatible h1:F3vclr7C3HpB1k9mxCGRMXq6FdUalZ6H/pNX4FP1v0Q= +github.com/google/flatbuffers v25.2.10+incompatible/go.mod h1:1AeVuKshWv4vARoZatz6mlQ0JxURH0Kv5+zNeJKJCa8= github.com/google/go-cmp v0.5.5 h1:Khx7svrCpmxxtHBq5j2mp/xVjsi8hQMfNLvJFAlrGgU= github.com/google/go-cmp v0.5.5/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/gofuzz v1.0.0/go.mod h1:dBl0BpW6vV/+mYPU4Po3pmUjxk6FQPldtuIdl/M65Eg= @@ -108,6 +110,8 @@ go.yarn.social/lextwt v0.1.1 h1:afyIZGvHBOZ81LD1OVg9wzP032+9sEihEHX7IdHkkPg= go.yarn.social/lextwt v0.1.1/go.mod h1:JOPCOh+3bHv+BMaFZpKzw6soiXbIlZD5b2f7YKDDjqk= go.yarn.social/lextwt v0.1.2 h1:hQYWMJmH2ziKsbFtqpf1eylGKq+CDSeQNtRW3rYL+kM= go.yarn.social/lextwt v0.1.2/go.mod h1:JOPCOh+3bHv+BMaFZpKzw6soiXbIlZD5b2f7YKDDjqk= +go.yarn.social/lextwt v0.1.4 h1:3p3GNzIcumDk+hwBHT8F0ySAcdPpP/wQz2WnczSTv+o= +go.yarn.social/lextwt v0.1.4/go.mod h1:JOPCOh+3bHv+BMaFZpKzw6soiXbIlZD5b2f7YKDDjqk= go.yarn.social/types v0.0.0-20250108134258-ed75fa653ede h1:XV9tuDQ605xxH4qIQPRHM1bOa7k0rJZ2RqA5kz2Nun4= go.yarn.social/types v0.0.0-20250108134258-ed75fa653ede/go.mod h1:+xnDkQ0T0S8emxWIsvxlCAoyF8gBaj0q81hr/VrKc0c= golang.org/x/arch v0.14.0 h1:z9JUEZWr8x4rR0OU6c4/4t6E6jOZ8/QBS2bBYBm4tx4= diff --git a/lextwt.avro b/lextwt.avro index 191bedb..67c1cd7 100644 --- a/lextwt.avro +++ b/lextwt.avro @@ -1,166 +1,209 @@ { "type": "record", - "name": "lextwt", + "name": "registry", "namespace": "social.yarn.lextwt", "fields": [ { - "name": "nick", - "type": "string" - }, - { - "name": "uri", - "type": "string" - }, - { - "name": "created", - "type": "long", - "logicalType": "timestamp-millis" - }, - { - "name": "createdZone", - "type": "string" - }, - { - "name": "createdOffset", - "type": "int" - }, - { - "name": "msg", - "type": { - "type": "array", + "name":"twts", + "type":{ + "type":"array", "items": { - "name": "elem", - "type": [ - "null", - "string", + "type": "record", + "name": "twt", + "fields": [ { - "type": "record", - "name": "linesep", - "fields": [] + "name": "nick", + "type": "string" }, { - "type": "record", - "name": "comment", - "fields": [ - { - "name": "comment", - "type": "string" - }, - { - "name": "key", - "type": "string" - }, - { - "name": "value", - "type": "string" - } - ] + "name": "uri", + "type": "string" }, { - "type": "record", - "name": "mention", - "fields": [ - { - "name": "name", - "type": "string" - }, - { - "name": "domain", - "type": "string" - }, - { - "name": "target", - "type": "string" - } - ] + "name": "created", + "type": "long", + "logicalType": "timestamp-millis" }, { - "type": "record", - "name": "bangmention", - "fields": [ - { - "name": "name", - "type": "string" - }, - { - "name": "target", - "type": "string" - } - ] + "name": "createdZone", + "type": "string" }, { - "type": "record", - "name": "hashtag", - "fields": [ - { - "name": "tag", - "type": "string" - }, - { - "name": "target", - "type": "string" - } - ] + "name": "createdOffset", + "type": "int" }, { - "type": "record", - "name": "subject", - "fields": [ - { - "name": "subject", - "type": "string" - }, - { - "name": "tag", - "type": "string" - }, - { - "name": "target", - "type": "string" + "name": "msg", + "type": { + "type": "array", + "items": { + "name": "elem", + "type": [ + "null", + "string", + { + "type": "record", + "name": "linesep", + "fields": [] + }, + { + "type": "record", + "name": "comment", + "fields": [ + { + "name": "comment", + "type": "string" + }, + { + "name": "key", + "type": "string" + }, + { + "name": "value", + "type": "string" + } + ] + }, + { + "type": "record", + "name": "mention", + "fields": [ + { + "name": "name", + "type": "string" + }, + { + "name": "domain", + "type": "string" + }, + { + "name": "target", + "type": "string" + } + ] + }, + { + "type": "record", + "name": "bangmention", + "fields": [ + { + "name": "name", + "type": "string" + }, + { + "name": "target", + "type": "string" + } + ] + }, + { + "type": "record", + "name": "hashtag", + "fields": [ + { + "name": "tag", + "type": "string" + }, + { + "name": "target", + "type": "string" + } + ] + }, + { + "type": "record", + "name": "subject", + "fields": [ + { + "name": "subject", + "type": "string" + }, + { + "name": "tag", + "type": "string" + }, + { + "name": "target", + "type": "string" + } + ] + }, + { + "type": "record", + "name": "link", + "fields": [ + { + "name": "linkType", + "type": "int", + "logicalType": "int8" + }, + { + "name": "text", + "type": "string" + }, + { + "name": "target", + "type": "string" + }, + { + "name": "title", + "type": "string" + } + ] + }, + { + "type": "record", + "name": "code", + "fields": [ + { + "name": "code", + "type": "string" + }, + { + "name": "codetype", + "type": "int", + "logicalType": "int8" + } + ] + } + ] } - ] - }, - { - "type": "record", - "name": "link", - "fields": [ - { - "name": "linkType", - "type": "int", - "logicalType": "int8" - }, - { - "name": "text", - "type": "string" - }, - { - "name": "target", - "type": "string" - }, - { - "name": "title", - "type": "string" - } - ] - }, - { - "type": "record", - "name": "code", - "fields": [ - { - "name": "code", - "type": "string" - }, - { - "name": "codetype", - "type": "int", - "logicalType": "int8" - } - ] + } } ] } } + }, + + { + "name":"twters", + "type":{ + "type": "array", + "items": { + "name": "twter", + "type":"record", + "fields":[ + { + "name": "nick", + "type": "string" + }, + { + "name": "uri", + "type": "string" + } + ] + } + } + }, + + + { + "name": "preamble", + "type": { + "type":"array", + "items": "social.yarn.lextwt.comment" + } } - ] -} \ No newline at end of file + + ] +} diff --git a/lextwt.fbs b/lextwt.fbs new file mode 100644 index 0000000..e550335 --- /dev/null +++ b/lextwt.fbs @@ -0,0 +1,95 @@ +namespace lextwt; + +table TwtRegistry { + preamble:[Comment]; + twters:[Twter]; + twts:[Twt]; +} + +enum LinkType : byte { + Standard = 1, + Media, + Plain, + Naked +} + +enum CodeType : byte { + Inline = 1, + Block +} + +table Twter { + nick:string; + uri:string; +} + +table DateTime { + timestamp:long; + offset:short; +} + +union Elem { + Comment, + Mention, + BangMention, + Tag, + Subject, + Text, + LineSeparator, + Link, + Code, +} + +table Msg { + elem:Elem; +} + +table Twt { + twter:Twter; + created:DateTime; + msg:[Msg]; +} + +table Comment { + comment:string; + key:string; + value:string; +} + +table Mention { + name: string; + target:string; +} + +table BangMention { + name:string; + target:string; +} + +table Tag { + tag:string; + target:string; +} + +table Subject { + subject:string; + tag:Tag; +} + +table Text { + text:string; +} + +table LineSeparator {} + +table Link { + type:LinkType = Standard; + alt:string; + target:string; + title:string; +} + +table Code { + type:CodeType = Inline; + code:string; +} \ No newline at end of file diff --git a/main.go b/main.go index 71eb439..8e9108e 100644 --- a/main.go +++ b/main.go @@ -2,8 +2,91 @@ package main import ( _ "embed" + "fmt" + "io" + "os" + + "go.yarn.social/lextwt" + "go.yarn.social/types" + + twt_avro "go.sour.is/lextwt-encoding/twt-avro" + twt_fbs "go.sour.is/lextwt-encoding/twt-fbs" ) -func main() { - +type TwtRegistry interface { + Twters() []*types.Twter + Preamble() lextwt.Comments + Twts() types.Twts + WriteTo(w io.Writer) (int64, error) +} + +//go:embed example.txt +var input []byte + +func main() { + in := os.Stdin //bytes.NewReader(input) + out := os.Stdout + + log := func(v ...any) { fmt.Fprint(os.Stderr, v...) } + + if len(os.Args) != 3 { + log("usage: lextwt-registry ") + } + + inputType := os.Args[1] + outputType := os.Args[2] + + var err error + var registry TwtRegistry + + switch inputType { + case "txt": + registry, err = lextwt.ParseRegistry(in) + case "fbs": + var b []byte + b, err = io.ReadAll(in) + if err == nil { + registry, err = twt_fbs.DecodeRegistry(b) + } + case "avro": + var b []byte + b, err = io.ReadAll(in) + if err == nil { + registry, err = twt_avro.DecodeRegistry(b) + } + default: + log(fmt.Errorf("unknown input format: %q", inputType)) + return + } + + if err != nil { + log(err) + return + } + + // log(registry) + + switch outputType { + case "txt": + registry.WriteTo(out) + case "fbs": + b := twt_fbs.EncodeRegistry(registry) + _, err = out.Write(b) + if err != nil { + log(err) + } + case "avro": + b, err := twt_avro.EncodeRegistry(registry) + if err != nil { + log(err) + } + _, err = out.Write(b) + if err != nil { + log(err) + } + + default: + log(fmt.Errorf("unknown output format: %q", outputType)) + return + } } diff --git a/twt-avro/example.txt b/twt-avro/example.txt new file mode 100644 index 0000000..8327305 --- /dev/null +++ b/twt-avro/example.txt @@ -0,0 +1,2 @@ +example https://example.org/twtxt.txt 2016-02-06T21:32:02.000Z @erlehmann is messing with timestamps in @buckket #twtxt :) +example https://example.org/twtxt.txt 2016-02-06T12:14:18.000Z Simple nodejs script to convert your twitter timeline to twtxt: https://t.co/txnWsC5jvA ( find my #twtxt at https://t.co/uN1KDXwJ8B ) diff --git a/twt-avro/gen.go b/twt-avro/gen.go index deaa350..e5f6f08 100644 --- a/twt-avro/gen.go +++ b/twt-avro/gen.go @@ -192,8 +192,8 @@ func (o *Code) Marshal() ([]byte, error) { return avro.Marshal(o.Schema(), o) } -// Lextwt is a generated struct. -type Lextwt struct { +// Twt is a generated struct. +type Twt struct { Nick string `avro:"nick"` URI string `avro:"uri"` Created int64 `avro:"created"` @@ -202,19 +202,66 @@ type Lextwt struct { Msg []any `avro:"msg"` } -var schemaLextwt = avro.MustParse(`{"name":"social.yarn.lextwt.lextwt","type":"record","fields":[{"name":"nick","type":"string"},{"name":"uri","type":"string"},{"name":"created","type":"long"},{"name":"createdZone","type":"string"},{"name":"createdOffset","type":"int"},{"name":"msg","type":{"type":"array","items":["null","string",{"name":"social.yarn.lextwt.linesep","type":"record","fields":[]},{"name":"social.yarn.lextwt.comment","type":"record","fields":[{"name":"comment","type":"string"},{"name":"key","type":"string"},{"name":"value","type":"string"}]},{"name":"social.yarn.lextwt.mention","type":"record","fields":[{"name":"name","type":"string"},{"name":"domain","type":"string"},{"name":"target","type":"string"}]},{"name":"social.yarn.lextwt.bangmention","type":"record","fields":[{"name":"name","type":"string"},{"name":"target","type":"string"}]},{"name":"social.yarn.lextwt.hashtag","type":"record","fields":[{"name":"tag","type":"string"},{"name":"target","type":"string"}]},{"name":"social.yarn.lextwt.subject","type":"record","fields":[{"name":"subject","type":"string"},{"name":"tag","type":"string"},{"name":"target","type":"string"}]},{"name":"social.yarn.lextwt.link","type":"record","fields":[{"name":"linkType","type":"int"},{"name":"text","type":"string"},{"name":"target","type":"string"},{"name":"title","type":"string"}]},{"name":"social.yarn.lextwt.code","type":"record","fields":[{"name":"code","type":"string"},{"name":"codetype","type":"int"}]}]}}]}`) +var schemaTwt = avro.MustParse(`{"name":"social.yarn.lextwt.twt","type":"record","fields":[{"name":"nick","type":"string"},{"name":"uri","type":"string"},{"name":"created","type":"long"},{"name":"createdZone","type":"string"},{"name":"createdOffset","type":"int"},{"name":"msg","type":{"type":"array","items":["null","string",{"name":"social.yarn.lextwt.linesep","type":"record","fields":[]},{"name":"social.yarn.lextwt.comment","type":"record","fields":[{"name":"comment","type":"string"},{"name":"key","type":"string"},{"name":"value","type":"string"}]},{"name":"social.yarn.lextwt.mention","type":"record","fields":[{"name":"name","type":"string"},{"name":"domain","type":"string"},{"name":"target","type":"string"}]},{"name":"social.yarn.lextwt.bangmention","type":"record","fields":[{"name":"name","type":"string"},{"name":"target","type":"string"}]},{"name":"social.yarn.lextwt.hashtag","type":"record","fields":[{"name":"tag","type":"string"},{"name":"target","type":"string"}]},{"name":"social.yarn.lextwt.subject","type":"record","fields":[{"name":"subject","type":"string"},{"name":"tag","type":"string"},{"name":"target","type":"string"}]},{"name":"social.yarn.lextwt.link","type":"record","fields":[{"name":"linkType","type":"int"},{"name":"text","type":"string"},{"name":"target","type":"string"},{"name":"title","type":"string"}]},{"name":"social.yarn.lextwt.code","type":"record","fields":[{"name":"code","type":"string"},{"name":"codetype","type":"int"}]}]}}]}`) -// Schema returns the schema for Lextwt. -func (o *Lextwt) Schema() avro.Schema { - return schemaLextwt +// Schema returns the schema for Twt. +func (o *Twt) Schema() avro.Schema { + return schemaTwt } // Unmarshal decodes b into the receiver. -func (o *Lextwt) Unmarshal(b []byte) error { +func (o *Twt) Unmarshal(b []byte) error { return avro.Unmarshal(o.Schema(), b, o) } // Marshal encodes the receiver. -func (o *Lextwt) Marshal() ([]byte, error) { +func (o *Twt) Marshal() ([]byte, error) { + return avro.Marshal(o.Schema(), o) +} + +// Twter is a generated struct. +type Twter struct { + Nick string `avro:"nick"` + URI string `avro:"uri"` +} + +var schemaTwter = avro.MustParse(`{"name":"social.yarn.lextwt.twter","type":"record","fields":[{"name":"nick","type":"string"},{"name":"uri","type":"string"}]}`) + +// Schema returns the schema for Twter. +func (o *Twter) Schema() avro.Schema { + return schemaTwter +} + +// Unmarshal decodes b into the receiver. +func (o *Twter) Unmarshal(b []byte) error { + return avro.Unmarshal(o.Schema(), b, o) +} + +// Marshal encodes the receiver. +func (o *Twter) Marshal() ([]byte, error) { + return avro.Marshal(o.Schema(), o) +} + +// Registry is a generated struct. +type Registry struct { + Twts []Twt `avro:"twts"` + Twters []Twter `avro:"twters"` + Preamble []Comment `avro:"preamble"` +} + +var schemaRegistry = avro.MustParse(`{"name":"social.yarn.lextwt.registry","type":"record","fields":[{"name":"twts","type":{"type":"array","items":{"name":"social.yarn.lextwt.twt","type":"record","fields":[{"name":"nick","type":"string"},{"name":"uri","type":"string"},{"name":"created","type":"long"},{"name":"createdZone","type":"string"},{"name":"createdOffset","type":"int"},{"name":"msg","type":{"type":"array","items":["null","string",{"name":"social.yarn.lextwt.linesep","type":"record","fields":[]},{"name":"social.yarn.lextwt.comment","type":"record","fields":[{"name":"comment","type":"string"},{"name":"key","type":"string"},{"name":"value","type":"string"}]},{"name":"social.yarn.lextwt.mention","type":"record","fields":[{"name":"name","type":"string"},{"name":"domain","type":"string"},{"name":"target","type":"string"}]},{"name":"social.yarn.lextwt.bangmention","type":"record","fields":[{"name":"name","type":"string"},{"name":"target","type":"string"}]},{"name":"social.yarn.lextwt.hashtag","type":"record","fields":[{"name":"tag","type":"string"},{"name":"target","type":"string"}]},{"name":"social.yarn.lextwt.subject","type":"record","fields":[{"name":"subject","type":"string"},{"name":"tag","type":"string"},{"name":"target","type":"string"}]},{"name":"social.yarn.lextwt.link","type":"record","fields":[{"name":"linkType","type":"int"},{"name":"text","type":"string"},{"name":"target","type":"string"},{"name":"title","type":"string"}]},{"name":"social.yarn.lextwt.code","type":"record","fields":[{"name":"code","type":"string"},{"name":"codetype","type":"int"}]}]}}]}}},{"name":"twters","type":{"type":"array","items":{"name":"social.yarn.lextwt.twter","type":"record","fields":[{"name":"nick","type":"string"},{"name":"uri","type":"string"}]}}},{"name":"preamble","type":{"type":"array","items":"social.yarn.lextwt.comment"}}]}`) + +// Schema returns the schema for Registry. +func (o *Registry) Schema() avro.Schema { + return schemaRegistry +} + +// Unmarshal decodes b into the receiver. +func (o *Registry) Unmarshal(b []byte) error { + return avro.Unmarshal(o.Schema(), b, o) +} + +// Marshal encodes the receiver. +func (o *Registry) Marshal() ([]byte, error) { return avro.Marshal(o.Schema(), o) } diff --git a/twt-avro/helper.go b/twt-avro/helper.go index eb62e9a..c15d79f 100644 --- a/twt-avro/helper.go +++ b/twt-avro/helper.go @@ -1,6 +1,7 @@ package twt_avro import ( + "io" "time" "github.com/hamba/avro" @@ -18,6 +19,9 @@ const ( keyLinesep = "social.yarn.lextwt.linesep" keyComment = "social.yarn.lextwt.comment" keyText = "social.yarn.lextwt.text" + keyTwt = "social.yarn.lextwt.twt" + keyTwter = "social.yarn.lextwt.twter" + keyRegistry = "social.yarn.lextwt.registry" ) func Register() { @@ -30,6 +34,9 @@ func Register() { avro.Register(keyBangmention, Bangmention{}) avro.Register(keyLinesep, Linesep{}) avro.Register(keyComment, Comment{}) + avro.Register(keyTwt, Twt{}) + avro.Register(keyTwter, Twter{}) + avro.Register(keyRegistry, Registry{}) } func Elem(o any) any { @@ -62,18 +69,18 @@ func Msg(items ...any) []any { return items } -func FromTwt(twt types.Twt) Lextwt { +func FromTwt(twt types.Twt) Twt { return FromLextwt(twt.(*lextwt.Twt)) } -func FromLextwt(twt *lextwt.Twt) Lextwt { +func FromLextwt(twt *lextwt.Twt) Twt { if twt == nil { - return Lextwt{} + return Twt{} } ts := twt.Created() _, offset := ts.Zone() - l := Lextwt{ + l := Twt{ Nick: twt.Twter().Nick, URI: twt.Twter().URI, Created: ts.UnixMilli(), @@ -95,7 +102,7 @@ func FromLextwt(twt *lextwt.Twt) Lextwt { case *lextwt.Subject: l.Msg = append(l.Msg, Elem(Subject{Subject: e.Subject(), Tag: e.Tag().Text(), Target: e.Tag().Target()})) case *lextwt.Code: - l.Msg = append(l.Msg, Elem(Code{Code: e.Text()})) + l.Msg = append(l.Msg, Elem(Code{Code: e.Text(), Codetype: int(e.CodeType())})) case *lextwt.Mention: l.Msg = append(l.Msg, Elem(Mention{Name: e.Name(), Domain: e.Domain(), Target: e.Target()})) case *lextwt.Tag: @@ -114,11 +121,11 @@ func FromLextwt(twt *lextwt.Twt) Lextwt { return l } -func (l Lextwt) ToTwt() types.Twt { +func (l Twt) ToTwt() types.Twt { return l.ToLextwt() } -func (lx Lextwt) ToLextwt() *lextwt.Twt { +func (lx Twt) ToLextwt() *lextwt.Twt { twter := types.Twter{ Nick: lx.Nick, URI: lx.URI, @@ -213,3 +220,60 @@ func read[T any](m map[string]any, k string) T { } return val } + +type TwtRegistry interface { + Twters() []*types.Twter + Preamble() lextwt.Comments + Twts() types.Twts + WriteTo(w io.Writer) (int64, error) +} + +func EncodeRegistry(r TwtRegistry) ([]byte, error) { + out := Registry{} + + for _, comment := range r.Preamble() { + if comment.Key() != "" { + out.Preamble = append(out.Preamble, Comment{Key: comment.Key(), Value: comment.Value()}) + continue + } + out.Preamble = append(out.Preamble, Comment{Comment: comment.Text()}) + } + + for _, twter := range r.Twters() { + out.Twters = append(out.Twters, Twter{Nick: twter.Nick, URI: twter.URI}) + } + + for _, twt := range r.Twts() { + out.Twts = append(out.Twts, FromTwt(twt)) + } + + return out.Marshal() +} + +func DecodeRegistry(b []byte) (TwtRegistry, error) { + var out Registry + if err := out.Unmarshal(b); err != nil { + return nil, err + } + + preamble := make(lextwt.Comments, len(out.Preamble)) + for _, comment := range out.Preamble { + if comment.Key != "" { + preamble = append(preamble, lextwt.NewCommentValue(comment.Comment, comment.Key, comment.Value)) + } else { + preamble = append(preamble, lextwt.NewComment(comment.Comment)) + } + } + + twters := make([]*types.Twter, len(out.Twters)) + for _, twter := range out.Twters { + twters = append(twters, &types.Twter{Nick:twter.Nick, URI:twter.URI}) + } + + twts := make(types.Twts, len(out.Twts)) + for _, twt := range out.Twts { + twts = append(twts, twt.ToTwt()) + } + + return lextwt.NewTwtRegistry(twters, preamble, twts), nil +} \ No newline at end of file diff --git a/twt-avro/helper_test.go b/twt-avro/helper_test.go index e9bf965..5d56c5d 100644 --- a/twt-avro/helper_test.go +++ b/twt-avro/helper_test.go @@ -1,9 +1,12 @@ package twt_avro_test import ( + "bytes" + _ "embed" "encoding/base64" "fmt" "log" + "os" "testing" "time" @@ -18,7 +21,7 @@ func TestMarshal(t *testing.T) { ts := must(time.Parse(time.RFC3339, "2021-01-24T02:19:54Z")) zone, offset := ts.Zone() - in := twt_avro.Lextwt{ + in := twt_avro.Twt{ Nick: "xuu", URI: "https://xuu.txt", Created: ts.UnixMilli(), @@ -43,7 +46,7 @@ func TestMarshal(t *testing.T) { fmt.Println(data) // Outputs: [54 6 102 111 111] - out := twt_avro.Lextwt{} + out := twt_avro.Twt{} err = out.Unmarshal(data) if err != nil { log.Fatal("unmarshal: ", err) @@ -93,7 +96,7 @@ func TestFromTwt(t *testing.T) { t.Log(enc(b)) - out := twt_avro.Lextwt{} + out := twt_avro.Twt{} err = out.Unmarshal(b) if err != nil { log.Fatal(err) @@ -103,7 +106,7 @@ func TestFromTwt(t *testing.T) { outlx := out.ToLextwt() - outText := fmt.Sprintf("%+l",outlx) + outText := fmt.Sprintf("%+l", outlx) t.Log(outText) if outText != test.in { t.Errorf("\nexpected %s\n got %s", test.in, outText) @@ -113,3 +116,29 @@ func TestFromTwt(t *testing.T) { } var enc = base64.RawStdEncoding.EncodeToString + +//go:embed example.txt +var input []byte + +func TestEncodeRegistry(t *testing.T) { + twt_avro.Register() + + registry, err := lextwt.ParseRegistry(bytes.NewReader(input)) + if err != nil { + log.Fatal(err) + } + + b, err := twt_avro.EncodeRegistry(registry) + if err != nil { + log.Fatal(err) + } + + t.Log(enc(b)) + + out, err := twt_avro.DecodeRegistry(b) + if err != nil { + log.Fatal(err) + } + + out.WriteTo(os.Stdout) +} diff --git a/twt-fbs/example.txt b/twt-fbs/example.txt new file mode 100644 index 0000000..8327305 --- /dev/null +++ b/twt-fbs/example.txt @@ -0,0 +1,2 @@ +example https://example.org/twtxt.txt 2016-02-06T21:32:02.000Z @erlehmann is messing with timestamps in @buckket #twtxt :) +example https://example.org/twtxt.txt 2016-02-06T12:14:18.000Z Simple nodejs script to convert your twitter timeline to twtxt: https://t.co/txnWsC5jvA ( find my #twtxt at https://t.co/uN1KDXwJ8B ) diff --git a/twt-fbs/helper.go b/twt-fbs/helper.go new file mode 100644 index 0000000..343deba --- /dev/null +++ b/twt-fbs/helper.go @@ -0,0 +1,483 @@ +package twt_fbs + +import ( + "io" + "time" + + flatbuffers "github.com/google/flatbuffers/go" + "go.yarn.social/lextwt" + "go.yarn.social/types" + + fbs "go.sour.is/lextwt-encoding/twt-fbs/lextwt" +) + +type TwtRegistry interface { + Twters() []*types.Twter + Preamble() lextwt.Comments + Twts() types.Twts + WriteTo(w io.Writer) (int64, error) +} + +func EncodeTwt(twt types.Twt) []byte { + lx, ok := twt.(*lextwt.Twt) + if !ok { + return nil + } + + return EncodeLextwt(lx) +} + +func EncodeLextwt(twt *lextwt.Twt) []byte { + b := flatbuffers.NewBuilder(0) + b.Finish(createTwt(b, twt)) + return b.FinishedBytes() +} + +func EncodeRegistry(lis TwtRegistry) []byte { + b := flatbuffers.NewBuilder(len(lis.Twts())) + b.Finish(createRegistry(b, lis)) + return b.FinishedBytes() +} + +func createRegistry(b *flatbuffers.Builder, r TwtRegistry) flatbuffers.UOffsetT { + preamble := make([]flatbuffers.UOffsetT, len(r.Preamble())) + twters := make([]flatbuffers.UOffsetT, len(r.Twters())) + twts := make([]flatbuffers.UOffsetT, len(r.Twts())) + + for i, twt := range r.Twts() { + if twt, ok := twt.(*lextwt.Twt); ok { + twts[i] = createTwt(b, twt) + } + } + + fbs.TwtRegistryStartTwtsVector(b, len(twts)) + for _, offset := range twts { + b.PrependUOffsetT(offset) + } + oTwts := b.EndVector(len(twts)) + + for _, twter := range r.Twters() { + twters = append(twters, createTwter(b, twter)) + } + + fbs.TwtRegistryStartTwtersVector(b, len(twters)) + for _, offset := range twters { + b.PrependUOffsetT(offset) + } + oTwters := b.EndVector(len(r.Twters())) + + for _, comment := range r.Preamble() { + preamble = append(preamble, createComment(b, comment)) + } + + fbs.TwtRegistryStartPreambleVector(b, len(preamble)) + for _, offset := range preamble { + b.PrependUOffsetT(offset) + } + oPreamble := b.EndVector(len(preamble)) + + fbs.TwtRegistryStart(b) + fbs.TwtRegistryAddTwts(b, oTwts) + fbs.TwtRegistryAddTwters(b, oTwters) + fbs.TwtRegistryAddPreamble(b, oPreamble) + return fbs.TwtRegistryEnd(b) +} + +func createTwt(b *flatbuffers.Builder, twt *lextwt.Twt) flatbuffers.UOffsetT { + twter := twt.Twter() + + oTwter := createTwter(b, &twter) + oCreated := createDateTime(b, twt.Created()) + oElems := createMsg(b, twt.Elems()) + + fbs.TwtStart(b) + fbs.TwtAddTwter(b, oTwter) + fbs.TwtAddCreated(b, oCreated) + fbs.TwtAddMsg(b, oElems) + + return fbs.TwtEnd(b) +} + +func createTwter(b *flatbuffers.Builder, twter *types.Twter) flatbuffers.UOffsetT { + nick := b.CreateString(twter.Nick) + uri := b.CreateString(twter.URI) + + fbs.TwterStart(b) + fbs.TwterAddNick(b, nick) + fbs.TwterAddUri(b, uri) + + return fbs.TwterEnd(b) +} + +func createDateTime(b *flatbuffers.Builder, ts time.Time) flatbuffers.UOffsetT { + _, offset := ts.Zone() + + fbs.DateTimeStart(b) + fbs.DateTimeAddTimestamp(b, ts.UnixMilli()) + fbs.DateTimeAddOffset(b, int16(offset)) + + return fbs.DateTimeEnd(b) +} + +func createMsg(b *flatbuffers.Builder, msgs []lextwt.Elem) flatbuffers.UOffsetT { + offsets := make([]flatbuffers.UOffsetT, len(msgs)) + for i, msg := range msgs { + offsets[i] = createElem(b, msg) + } + + fbs.TwtStartMsgVector(b, len(msgs)) + for _, offset := range offsets { + b.PrependUOffsetT(offset) + } + + return b.EndVector(len(msgs)) +} + +func createElem(b *flatbuffers.Builder, elem lextwt.Elem) flatbuffers.UOffsetT { + + if elem == lextwt.LineSeparator { + offset := createLineSeparator(b) + + fbs.MsgStart(b) + fbs.MsgAddElemType(b, fbs.ElemLineSeparator) + fbs.MsgAddElem(b, offset) + + return fbs.MsgEnd(b) + } + + var oElem flatbuffers.UOffsetT + var oType fbs.Elem + + switch e := elem.(type) { + case *lextwt.BangMention: + oType = fbs.ElemBangMention + oElem = createBangMention(b, e) + case *lextwt.Code: + oType = fbs.ElemCode + oElem = createCode(b, e) + case *lextwt.Comment: + oType = fbs.ElemComment + oElem = createComment(b, e) + case *lextwt.Link: + oType = fbs.ElemLink + oElem = createLink(b, e) + case *lextwt.Mention: + oType = fbs.ElemMention + oElem = createMention(b, e) + case *lextwt.Subject: + oType = fbs.ElemSubject + oElem = createSubject(b, e) + case *lextwt.Tag: + oType = fbs.ElemTag + oElem = createTag(b, e) + case *lextwt.Text: + oType = fbs.ElemText + oElem = createText(b, e) + default: + fbs.MsgStart(b) + fbs.MsgAddElemType(b, fbs.ElemNONE) + + return fbs.MsgEnd(b) + } + + fbs.MsgStart(b) + fbs.MsgAddElemType(b, oType) + fbs.MsgAddElem(b, oElem) + + return fbs.MsgEnd(b) +} + +func createLineSeparator(b *flatbuffers.Builder) flatbuffers.UOffsetT { + fbs.LineSeparatorStart(b) + + return fbs.LineSeparatorEnd(b) +} + +func createBangMention(b *flatbuffers.Builder, mention *lextwt.BangMention) flatbuffers.UOffsetT { + name := b.CreateString(mention.Name()) + target := b.CreateString(mention.Target()) + + fbs.BangMentionStart(b) + fbs.BangMentionAddName(b, name) + fbs.BangMentionAddTarget(b, target) + + return fbs.BangMentionEnd(b) +} + +func createCode(b *flatbuffers.Builder, code *lextwt.Code) flatbuffers.UOffsetT { + typ := fbs.CodeType(code.CodeType()) + value := b.CreateString(code.Text()) + + fbs.CodeStart(b) + fbs.CodeAddType(b, typ) + fbs.CodeAddCode(b, value) + + return fbs.CodeEnd(b) +} + +func createComment(b *flatbuffers.Builder, comment *lextwt.Comment) flatbuffers.UOffsetT { + text := b.CreateString(comment.Text()) + var key, value flatbuffers.UOffsetT + + if comment.Key() != "" { + key = b.CreateString(comment.Key()) + value = b.CreateString(comment.Value()) + } + + fbs.CommentStart(b) + fbs.CommentAddComment(b, text) + if comment.Key() != "" { + fbs.CommentAddKey(b, key) + fbs.CommentAddValue(b, value) + } + + return fbs.CommentEnd(b) +} + +func createLink(b *flatbuffers.Builder, link *lextwt.Link) flatbuffers.UOffsetT { + linkType := fbs.LinkType(link.LinkType()) + alt := b.CreateString(link.Text()) + target := b.CreateString(link.Target()) + title := b.CreateString(link.Title()) + + fbs.LinkStart(b) + fbs.LinkAddType(b, linkType) + fbs.LinkAddAlt(b, alt) + fbs.LinkAddTarget(b, target) + fbs.LinkAddTitle(b, title) + + return fbs.LinkEnd(b) +} + +func createMention(b *flatbuffers.Builder, mention *lextwt.Mention) flatbuffers.UOffsetT { + name := b.CreateString(mention.Name()) + target := b.CreateString(mention.Target()) + + fbs.MentionStart(b) + fbs.MentionAddName(b, name) + fbs.MentionAddTarget(b, target) + + return fbs.MentionEnd(b) +} + +func createSubject(b *flatbuffers.Builder, subject *lextwt.Subject) flatbuffers.UOffsetT { + var oTag flatbuffers.UOffsetT + if tag, ok := subject.Tag().(*lextwt.Tag); ok && tag != nil { + oTag = createTag(b, tag) + } + oSubject := b.CreateString(subject.Subject()) + + fbs.SubjectStart(b) + fbs.SubjectAddSubject(b, oSubject) + if oTag != 0 { + fbs.SubjectAddTag(b, oTag) + } + + return fbs.SubjectEnd(b) +} + +func createTag(b *flatbuffers.Builder, tag *lextwt.Tag) flatbuffers.UOffsetT { + text := b.CreateString(tag.Text()) + target := b.CreateString(tag.Target()) + + fbs.TagStart(b) + fbs.TagAddTag(b, text) + fbs.TagAddTarget(b, target) + + return fbs.TagEnd(b) +} + +func createText(b *flatbuffers.Builder, text *lextwt.Text) flatbuffers.UOffsetT { + literal := b.CreateString(text.Literal()) + + fbs.TextStart(b) + fbs.TextAddText(b, literal) + + return fbs.TextEnd(b) +} + +func DecodeTwt(in []byte) (types.Twt, error) { + return DecodeLextwt(in) +} + +func DecodeLextwt(in []byte) (*lextwt.Twt, error) { + o := fbs.GetRootAsTwt(in, 0) + return fromTwt(o), nil +} + +func fromTwt(o *fbs.Twt) *lextwt.Twt { + elems := make([]lextwt.Elem, o.MsgLength()) + + for i := 0; i < o.MsgLength(); i++ { + var m fbs.Msg + + if o.Msg(&m, i) { + elems[len(elems)-i-1] = fromMsg(&m) + } + } + + return lextwt.NewTwt( + *fromTwter(o.Twter(nil)), + fromDateTime(o.Created(nil)), + elems..., + ) +} + +func DecodeRegistry(in []byte) (TwtRegistry, error) { + root := fbs.GetRootAsTwtRegistry(in, 0) + return fromRegistry(root), nil +} +func fromRegistry(r *fbs.TwtRegistry) TwtRegistry { + twts := make([]types.Twt, r.TwtsLength()) + for i := 0; i < r.TwtsLength(); i++ { + twt := &fbs.Twt{} + r.Twts(twt, i) + twts[len(twts)-i-1] = fromTwt(twt) + } + + twters := make([]*types.Twter, r.TwtersLength()) + for i := 0; i < r.TwtersLength(); i++ { + twter := &fbs.Twter{} + if r.Twters(twter, i) { + twters[len(twters)-i-1] = fromTwter(twter) + } + } + + preamble := make(lextwt.Comments, r.PreambleLength()) + for i := 0; i < r.PreambleLength(); i++ { + comment := &fbs.Comment{} + if r.Preamble(comment, i) { + preamble[len(preamble)-i-1] = fromComment(comment) + } + } + + return lextwt.NewTwtRegistry(twters, preamble, twts) +} + +func fromDateTime(o *fbs.DateTime) *lextwt.DateTime { + if o == nil { + return nil + } + t := time.UnixMilli(o.Timestamp()) + t.Add(time.Duration(o.Offset()) * time.Second) + + return lextwt.NewDateTime(t, t.Format(time.RFC3339)) +} + +func fromTwter(o *fbs.Twter) *types.Twter { + t := &types.Twter{} + + if o != nil { + t.Nick = string(o.Nick()) + t.URI = string(o.Uri()) + } + return t +} + +func fromMsg(o *fbs.Msg) lextwt.Elem { + elem := &flatbuffers.Table{} + + if o.Elem(elem) { + switch o.ElemType() { + case fbs.ElemText: + return from(elem, fromText) + case fbs.ElemSubject: + return from(elem, fromSubject) + case fbs.ElemCode: + return from(elem, fromCode) + case fbs.ElemMention: + return from(elem, fromMention) + case fbs.ElemLink: + return from(elem, fromLink) + case fbs.ElemComment: + return from(elem, fromComment) + case fbs.ElemBangMention: + return from(elem, fromBangMention) + case fbs.ElemTag: + return from(elem, fromTag) + case fbs.ElemLineSeparator: + return lextwt.LineSeparator + } + } + return nil +} + +type PA[T any] interface { + Init([]byte, flatbuffers.UOffsetT) + *T +} + +func from[T, A any, U PA[A]](tbl *flatbuffers.Table, fn func(U) T) T { + var elem U = new(A) + elem.Init(tbl.Bytes, tbl.Pos) + return fn(elem) +} + +func fromText(o *fbs.Text) *lextwt.Text { + if o == nil { + return nil + } + return lextwt.NewText(string(o.Text())) +} + +func fromLink(o *fbs.Link) *lextwt.Link { + if o == nil { + return nil + } + + if o.Type() == fbs.LinkTypeMedia { + return lextwt.NewMedia(string(o.Alt()), string(o.Target()), string(o.Title())) + } + + return lextwt.NewLink(string(o.Alt()), string(o.Target()), lextwt.LinkType(o.Type())) +} + +func fromComment(o *fbs.Comment) *lextwt.Comment { + if o == nil { + return nil + } + if len(o.Key()) > 0 { + return lextwt.NewCommentValue(string(o.Comment()), string(o.Key()), string(o.Value())) + } + + return lextwt.NewComment(string(o.Comment())) +} + +func fromTag(o *fbs.Tag) *lextwt.Tag { + if o == nil { + return nil + } + return lextwt.NewTag(string(o.Tag()), string(o.Target())) +} + +func fromSubject(o *fbs.Subject) *lextwt.Subject { + if o == nil { + return nil + } + if tag := o.Tag(nil); tag != nil { + return lextwt.NewSubjectTag(string(tag.Tag()), string(tag.Target())) + } + + return lextwt.NewSubject(string(o.Subject())) +} + +func fromCode(o *fbs.Code) *lextwt.Code { + if o == nil { + return nil + } + return lextwt.NewCode(string(o.Code()), lextwt.CodeType(o.Type())) +} + +func fromMention(o *fbs.Mention) *lextwt.Mention { + if o == nil { + return nil + } + return lextwt.NewMention(string(o.Name()), string(o.Target())) +} + +func fromBangMention(o *fbs.BangMention) *lextwt.BangMention { + if o == nil { + return nil + } + return lextwt.NewBangMention(string(o.Name()), string(o.Target())) +} diff --git a/twt-fbs/helper_test.go b/twt-fbs/helper_test.go new file mode 100644 index 0000000..1dd853c --- /dev/null +++ b/twt-fbs/helper_test.go @@ -0,0 +1,62 @@ +package twt_fbs_test + +import ( + "bytes" + _ "embed" + "encoding/base64" + "fmt" + "log" + "testing" + + "go.yarn.social/lextwt" + "go.yarn.social/types" + + twt_fbs "go.sour.is/lextwt-encoding/twt-fbs" +) + +func TestToLextwt(t *testing.T) { + twt, err := lextwt.ParseLine("2021-01-24T02:19:54-07:00 (#asdf1234) @xuu This is a `twt`!\u2028Next Line!", &types.Twter{Nick: "xuu@sour.is", URI: "https://xuu.txt"}) + if err != nil { + log.Fatal(err) + } + + fb := twt_fbs.EncodeTwt(twt) + + // t.Log(enc(fb)) + + out, err := twt_fbs.DecodeLextwt(fb) + if err != nil { + log.Fatal(err) + } + + outs := fmt.Sprint(out) + twts := fmt.Sprint(twt) + + if outs != twts { + t.Errorf("got %q, want %q", outs, twts) + } +} + +//go:embed example.txt +var input []byte + +func TestToRegistry(t *testing.T) { + registry, err := lextwt.ParseRegistry(bytes.NewReader(input)) + if err != nil { + log.Fatal(err) + } + + fb := twt_fbs.EncodeRegistry(registry) + + t.Log(enc(fb)) + + out, err := twt_fbs.DecodeRegistry(fb) + if err != nil { + log.Fatal(err) + } + + outs := fmt.Sprint(out) + t.Log(outs) +} + +var enc = base64.RawStdEncoding.EncodeToString diff --git a/twt-fbs/lextwt/BangMention.go b/twt-fbs/lextwt/BangMention.go new file mode 100644 index 0000000..25c0b84 --- /dev/null +++ b/twt-fbs/lextwt/BangMention.go @@ -0,0 +1,71 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package lextwt + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +type BangMention struct { + _tab flatbuffers.Table +} + +func GetRootAsBangMention(buf []byte, offset flatbuffers.UOffsetT) *BangMention { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &BangMention{} + x.Init(buf, n+offset) + return x +} + +func FinishBangMentionBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) { + builder.Finish(offset) +} + +func GetSizePrefixedRootAsBangMention(buf []byte, offset flatbuffers.UOffsetT) *BangMention { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &BangMention{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func FinishSizePrefixedBangMentionBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) { + builder.FinishSizePrefixed(offset) +} + +func (rcv *BangMention) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *BangMention) Table() flatbuffers.Table { + return rcv._tab +} + +func (rcv *BangMention) Name() []byte { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + return rcv._tab.ByteVector(o + rcv._tab.Pos) + } + return nil +} + +func (rcv *BangMention) Target() []byte { + o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) + if o != 0 { + return rcv._tab.ByteVector(o + rcv._tab.Pos) + } + return nil +} + +func BangMentionStart(builder *flatbuffers.Builder) { + builder.StartObject(2) +} +func BangMentionAddName(builder *flatbuffers.Builder, name flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(name), 0) +} +func BangMentionAddTarget(builder *flatbuffers.Builder, target flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(1, flatbuffers.UOffsetT(target), 0) +} +func BangMentionEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/twt-fbs/lextwt/Code.go b/twt-fbs/lextwt/Code.go new file mode 100644 index 0000000..8601888 --- /dev/null +++ b/twt-fbs/lextwt/Code.go @@ -0,0 +1,75 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package lextwt + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +type Code struct { + _tab flatbuffers.Table +} + +func GetRootAsCode(buf []byte, offset flatbuffers.UOffsetT) *Code { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &Code{} + x.Init(buf, n+offset) + return x +} + +func FinishCodeBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) { + builder.Finish(offset) +} + +func GetSizePrefixedRootAsCode(buf []byte, offset flatbuffers.UOffsetT) *Code { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &Code{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func FinishSizePrefixedCodeBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) { + builder.FinishSizePrefixed(offset) +} + +func (rcv *Code) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *Code) Table() flatbuffers.Table { + return rcv._tab +} + +func (rcv *Code) Type() CodeType { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + return CodeType(rcv._tab.GetInt8(o + rcv._tab.Pos)) + } + return 1 +} + +func (rcv *Code) MutateType(n CodeType) bool { + return rcv._tab.MutateInt8Slot(4, int8(n)) +} + +func (rcv *Code) Code() []byte { + o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) + if o != 0 { + return rcv._tab.ByteVector(o + rcv._tab.Pos) + } + return nil +} + +func CodeStart(builder *flatbuffers.Builder) { + builder.StartObject(2) +} +func CodeAddType(builder *flatbuffers.Builder, type_ CodeType) { + builder.PrependInt8Slot(0, int8(type_), 1) +} +func CodeAddCode(builder *flatbuffers.Builder, code flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(1, flatbuffers.UOffsetT(code), 0) +} +func CodeEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/twt-fbs/lextwt/CodeType.go b/twt-fbs/lextwt/CodeType.go new file mode 100644 index 0000000..38a4152 --- /dev/null +++ b/twt-fbs/lextwt/CodeType.go @@ -0,0 +1,29 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package lextwt + +import "strconv" + +type CodeType int8 + +const ( + CodeTypeInline CodeType = 1 + CodeTypeBlock CodeType = 2 +) + +var EnumNamesCodeType = map[CodeType]string{ + CodeTypeInline: "Inline", + CodeTypeBlock: "Block", +} + +var EnumValuesCodeType = map[string]CodeType{ + "Inline": CodeTypeInline, + "Block": CodeTypeBlock, +} + +func (v CodeType) String() string { + if s, ok := EnumNamesCodeType[v]; ok { + return s + } + return "CodeType(" + strconv.FormatInt(int64(v), 10) + ")" +} diff --git a/twt-fbs/lextwt/Comment.go b/twt-fbs/lextwt/Comment.go new file mode 100644 index 0000000..dbbbf3a --- /dev/null +++ b/twt-fbs/lextwt/Comment.go @@ -0,0 +1,82 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package lextwt + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +type Comment struct { + _tab flatbuffers.Table +} + +func GetRootAsComment(buf []byte, offset flatbuffers.UOffsetT) *Comment { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &Comment{} + x.Init(buf, n+offset) + return x +} + +func FinishCommentBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) { + builder.Finish(offset) +} + +func GetSizePrefixedRootAsComment(buf []byte, offset flatbuffers.UOffsetT) *Comment { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &Comment{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func FinishSizePrefixedCommentBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) { + builder.FinishSizePrefixed(offset) +} + +func (rcv *Comment) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *Comment) Table() flatbuffers.Table { + return rcv._tab +} + +func (rcv *Comment) Comment() []byte { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + return rcv._tab.ByteVector(o + rcv._tab.Pos) + } + return nil +} + +func (rcv *Comment) Key() []byte { + o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) + if o != 0 { + return rcv._tab.ByteVector(o + rcv._tab.Pos) + } + return nil +} + +func (rcv *Comment) Value() []byte { + o := flatbuffers.UOffsetT(rcv._tab.Offset(8)) + if o != 0 { + return rcv._tab.ByteVector(o + rcv._tab.Pos) + } + return nil +} + +func CommentStart(builder *flatbuffers.Builder) { + builder.StartObject(3) +} +func CommentAddComment(builder *flatbuffers.Builder, comment flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(comment), 0) +} +func CommentAddKey(builder *flatbuffers.Builder, key flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(1, flatbuffers.UOffsetT(key), 0) +} +func CommentAddValue(builder *flatbuffers.Builder, value flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(2, flatbuffers.UOffsetT(value), 0) +} +func CommentEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/twt-fbs/lextwt/DateTime.go b/twt-fbs/lextwt/DateTime.go new file mode 100644 index 0000000..360dcba --- /dev/null +++ b/twt-fbs/lextwt/DateTime.go @@ -0,0 +1,79 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package lextwt + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +type DateTime struct { + _tab flatbuffers.Table +} + +func GetRootAsDateTime(buf []byte, offset flatbuffers.UOffsetT) *DateTime { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &DateTime{} + x.Init(buf, n+offset) + return x +} + +func FinishDateTimeBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) { + builder.Finish(offset) +} + +func GetSizePrefixedRootAsDateTime(buf []byte, offset flatbuffers.UOffsetT) *DateTime { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &DateTime{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func FinishSizePrefixedDateTimeBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) { + builder.FinishSizePrefixed(offset) +} + +func (rcv *DateTime) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *DateTime) Table() flatbuffers.Table { + return rcv._tab +} + +func (rcv *DateTime) Timestamp() int64 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + return rcv._tab.GetInt64(o + rcv._tab.Pos) + } + return 0 +} + +func (rcv *DateTime) MutateTimestamp(n int64) bool { + return rcv._tab.MutateInt64Slot(4, n) +} + +func (rcv *DateTime) Offset() int16 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) + if o != 0 { + return rcv._tab.GetInt16(o + rcv._tab.Pos) + } + return 0 +} + +func (rcv *DateTime) MutateOffset(n int16) bool { + return rcv._tab.MutateInt16Slot(6, n) +} + +func DateTimeStart(builder *flatbuffers.Builder) { + builder.StartObject(2) +} +func DateTimeAddTimestamp(builder *flatbuffers.Builder, timestamp int64) { + builder.PrependInt64Slot(0, timestamp, 0) +} +func DateTimeAddOffset(builder *flatbuffers.Builder, offset int16) { + builder.PrependInt16Slot(1, offset, 0) +} +func DateTimeEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/twt-fbs/lextwt/Elem.go b/twt-fbs/lextwt/Elem.go new file mode 100644 index 0000000..be8dda8 --- /dev/null +++ b/twt-fbs/lextwt/Elem.go @@ -0,0 +1,53 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package lextwt + +import "strconv" + +type Elem byte + +const ( + ElemNONE Elem = 0 + ElemComment Elem = 1 + ElemMention Elem = 2 + ElemBangMention Elem = 3 + ElemTag Elem = 4 + ElemSubject Elem = 5 + ElemText Elem = 6 + ElemLineSeparator Elem = 7 + ElemLink Elem = 8 + ElemCode Elem = 9 +) + +var EnumNamesElem = map[Elem]string{ + ElemNONE: "NONE", + ElemComment: "Comment", + ElemMention: "Mention", + ElemBangMention: "BangMention", + ElemTag: "Tag", + ElemSubject: "Subject", + ElemText: "Text", + ElemLineSeparator: "LineSeparator", + ElemLink: "Link", + ElemCode: "Code", +} + +var EnumValuesElem = map[string]Elem{ + "NONE": ElemNONE, + "Comment": ElemComment, + "Mention": ElemMention, + "BangMention": ElemBangMention, + "Tag": ElemTag, + "Subject": ElemSubject, + "Text": ElemText, + "LineSeparator": ElemLineSeparator, + "Link": ElemLink, + "Code": ElemCode, +} + +func (v Elem) String() string { + if s, ok := EnumNamesElem[v]; ok { + return s + } + return "Elem(" + strconv.FormatInt(int64(v), 10) + ")" +} diff --git a/twt-fbs/lextwt/LineSeparator.go b/twt-fbs/lextwt/LineSeparator.go new file mode 100644 index 0000000..06270b1 --- /dev/null +++ b/twt-fbs/lextwt/LineSeparator.go @@ -0,0 +1,49 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package lextwt + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +type LineSeparator struct { + _tab flatbuffers.Table +} + +func GetRootAsLineSeparator(buf []byte, offset flatbuffers.UOffsetT) *LineSeparator { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &LineSeparator{} + x.Init(buf, n+offset) + return x +} + +func FinishLineSeparatorBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) { + builder.Finish(offset) +} + +func GetSizePrefixedRootAsLineSeparator(buf []byte, offset flatbuffers.UOffsetT) *LineSeparator { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &LineSeparator{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func FinishSizePrefixedLineSeparatorBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) { + builder.FinishSizePrefixed(offset) +} + +func (rcv *LineSeparator) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *LineSeparator) Table() flatbuffers.Table { + return rcv._tab +} + +func LineSeparatorStart(builder *flatbuffers.Builder) { + builder.StartObject(0) +} +func LineSeparatorEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/twt-fbs/lextwt/Link.go b/twt-fbs/lextwt/Link.go new file mode 100644 index 0000000..fbb7577 --- /dev/null +++ b/twt-fbs/lextwt/Link.go @@ -0,0 +1,97 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package lextwt + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +type Link struct { + _tab flatbuffers.Table +} + +func GetRootAsLink(buf []byte, offset flatbuffers.UOffsetT) *Link { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &Link{} + x.Init(buf, n+offset) + return x +} + +func FinishLinkBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) { + builder.Finish(offset) +} + +func GetSizePrefixedRootAsLink(buf []byte, offset flatbuffers.UOffsetT) *Link { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &Link{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func FinishSizePrefixedLinkBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) { + builder.FinishSizePrefixed(offset) +} + +func (rcv *Link) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *Link) Table() flatbuffers.Table { + return rcv._tab +} + +func (rcv *Link) Type() LinkType { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + return LinkType(rcv._tab.GetInt8(o + rcv._tab.Pos)) + } + return 1 +} + +func (rcv *Link) MutateType(n LinkType) bool { + return rcv._tab.MutateInt8Slot(4, int8(n)) +} + +func (rcv *Link) Alt() []byte { + o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) + if o != 0 { + return rcv._tab.ByteVector(o + rcv._tab.Pos) + } + return nil +} + +func (rcv *Link) Target() []byte { + o := flatbuffers.UOffsetT(rcv._tab.Offset(8)) + if o != 0 { + return rcv._tab.ByteVector(o + rcv._tab.Pos) + } + return nil +} + +func (rcv *Link) Title() []byte { + o := flatbuffers.UOffsetT(rcv._tab.Offset(10)) + if o != 0 { + return rcv._tab.ByteVector(o + rcv._tab.Pos) + } + return nil +} + +func LinkStart(builder *flatbuffers.Builder) { + builder.StartObject(4) +} +func LinkAddType(builder *flatbuffers.Builder, type_ LinkType) { + builder.PrependInt8Slot(0, int8(type_), 1) +} +func LinkAddAlt(builder *flatbuffers.Builder, alt flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(1, flatbuffers.UOffsetT(alt), 0) +} +func LinkAddTarget(builder *flatbuffers.Builder, target flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(2, flatbuffers.UOffsetT(target), 0) +} +func LinkAddTitle(builder *flatbuffers.Builder, title flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(3, flatbuffers.UOffsetT(title), 0) +} +func LinkEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/twt-fbs/lextwt/LinkType.go b/twt-fbs/lextwt/LinkType.go new file mode 100644 index 0000000..80801f2 --- /dev/null +++ b/twt-fbs/lextwt/LinkType.go @@ -0,0 +1,35 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package lextwt + +import "strconv" + +type LinkType int8 + +const ( + LinkTypeStandard LinkType = 1 + LinkTypeMedia LinkType = 2 + LinkTypePlain LinkType = 3 + LinkTypeNaked LinkType = 4 +) + +var EnumNamesLinkType = map[LinkType]string{ + LinkTypeStandard: "Standard", + LinkTypeMedia: "Media", + LinkTypePlain: "Plain", + LinkTypeNaked: "Naked", +} + +var EnumValuesLinkType = map[string]LinkType{ + "Standard": LinkTypeStandard, + "Media": LinkTypeMedia, + "Plain": LinkTypePlain, + "Naked": LinkTypeNaked, +} + +func (v LinkType) String() string { + if s, ok := EnumNamesLinkType[v]; ok { + return s + } + return "LinkType(" + strconv.FormatInt(int64(v), 10) + ")" +} diff --git a/twt-fbs/lextwt/Mention.go b/twt-fbs/lextwt/Mention.go new file mode 100644 index 0000000..eae4a55 --- /dev/null +++ b/twt-fbs/lextwt/Mention.go @@ -0,0 +1,71 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package lextwt + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +type Mention struct { + _tab flatbuffers.Table +} + +func GetRootAsMention(buf []byte, offset flatbuffers.UOffsetT) *Mention { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &Mention{} + x.Init(buf, n+offset) + return x +} + +func FinishMentionBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) { + builder.Finish(offset) +} + +func GetSizePrefixedRootAsMention(buf []byte, offset flatbuffers.UOffsetT) *Mention { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &Mention{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func FinishSizePrefixedMentionBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) { + builder.FinishSizePrefixed(offset) +} + +func (rcv *Mention) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *Mention) Table() flatbuffers.Table { + return rcv._tab +} + +func (rcv *Mention) Name() []byte { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + return rcv._tab.ByteVector(o + rcv._tab.Pos) + } + return nil +} + +func (rcv *Mention) Target() []byte { + o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) + if o != 0 { + return rcv._tab.ByteVector(o + rcv._tab.Pos) + } + return nil +} + +func MentionStart(builder *flatbuffers.Builder) { + builder.StartObject(2) +} +func MentionAddName(builder *flatbuffers.Builder, name flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(name), 0) +} +func MentionAddTarget(builder *flatbuffers.Builder, target flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(1, flatbuffers.UOffsetT(target), 0) +} +func MentionEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/twt-fbs/lextwt/Msg.go b/twt-fbs/lextwt/Msg.go new file mode 100644 index 0000000..e13449b --- /dev/null +++ b/twt-fbs/lextwt/Msg.go @@ -0,0 +1,76 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package lextwt + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +type Msg struct { + _tab flatbuffers.Table +} + +func GetRootAsMsg(buf []byte, offset flatbuffers.UOffsetT) *Msg { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &Msg{} + x.Init(buf, n+offset) + return x +} + +func FinishMsgBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) { + builder.Finish(offset) +} + +func GetSizePrefixedRootAsMsg(buf []byte, offset flatbuffers.UOffsetT) *Msg { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &Msg{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func FinishSizePrefixedMsgBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) { + builder.FinishSizePrefixed(offset) +} + +func (rcv *Msg) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *Msg) Table() flatbuffers.Table { + return rcv._tab +} + +func (rcv *Msg) ElemType() Elem { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + return Elem(rcv._tab.GetByte(o + rcv._tab.Pos)) + } + return 0 +} + +func (rcv *Msg) MutateElemType(n Elem) bool { + return rcv._tab.MutateByteSlot(4, byte(n)) +} + +func (rcv *Msg) Elem(obj *flatbuffers.Table) bool { + o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) + if o != 0 { + rcv._tab.Union(obj, o) + return true + } + return false +} + +func MsgStart(builder *flatbuffers.Builder) { + builder.StartObject(2) +} +func MsgAddElemType(builder *flatbuffers.Builder, elemType Elem) { + builder.PrependByteSlot(0, byte(elemType), 0) +} +func MsgAddElem(builder *flatbuffers.Builder, elem flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(1, flatbuffers.UOffsetT(elem), 0) +} +func MsgEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/twt-fbs/lextwt/Subject.go b/twt-fbs/lextwt/Subject.go new file mode 100644 index 0000000..72b1721 --- /dev/null +++ b/twt-fbs/lextwt/Subject.go @@ -0,0 +1,76 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package lextwt + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +type Subject struct { + _tab flatbuffers.Table +} + +func GetRootAsSubject(buf []byte, offset flatbuffers.UOffsetT) *Subject { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &Subject{} + x.Init(buf, n+offset) + return x +} + +func FinishSubjectBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) { + builder.Finish(offset) +} + +func GetSizePrefixedRootAsSubject(buf []byte, offset flatbuffers.UOffsetT) *Subject { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &Subject{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func FinishSizePrefixedSubjectBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) { + builder.FinishSizePrefixed(offset) +} + +func (rcv *Subject) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *Subject) Table() flatbuffers.Table { + return rcv._tab +} + +func (rcv *Subject) Subject() []byte { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + return rcv._tab.ByteVector(o + rcv._tab.Pos) + } + return nil +} + +func (rcv *Subject) Tag(obj *Tag) *Tag { + o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) + if o != 0 { + x := rcv._tab.Indirect(o + rcv._tab.Pos) + if obj == nil { + obj = new(Tag) + } + obj.Init(rcv._tab.Bytes, x) + return obj + } + return nil +} + +func SubjectStart(builder *flatbuffers.Builder) { + builder.StartObject(2) +} +func SubjectAddSubject(builder *flatbuffers.Builder, subject flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(subject), 0) +} +func SubjectAddTag(builder *flatbuffers.Builder, tag flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(1, flatbuffers.UOffsetT(tag), 0) +} +func SubjectEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/twt-fbs/lextwt/Tag.go b/twt-fbs/lextwt/Tag.go new file mode 100644 index 0000000..b852154 --- /dev/null +++ b/twt-fbs/lextwt/Tag.go @@ -0,0 +1,71 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package lextwt + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +type Tag struct { + _tab flatbuffers.Table +} + +func GetRootAsTag(buf []byte, offset flatbuffers.UOffsetT) *Tag { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &Tag{} + x.Init(buf, n+offset) + return x +} + +func FinishTagBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) { + builder.Finish(offset) +} + +func GetSizePrefixedRootAsTag(buf []byte, offset flatbuffers.UOffsetT) *Tag { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &Tag{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func FinishSizePrefixedTagBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) { + builder.FinishSizePrefixed(offset) +} + +func (rcv *Tag) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *Tag) Table() flatbuffers.Table { + return rcv._tab +} + +func (rcv *Tag) Tag() []byte { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + return rcv._tab.ByteVector(o + rcv._tab.Pos) + } + return nil +} + +func (rcv *Tag) Target() []byte { + o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) + if o != 0 { + return rcv._tab.ByteVector(o + rcv._tab.Pos) + } + return nil +} + +func TagStart(builder *flatbuffers.Builder) { + builder.StartObject(2) +} +func TagAddTag(builder *flatbuffers.Builder, tag flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(tag), 0) +} +func TagAddTarget(builder *flatbuffers.Builder, target flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(1, flatbuffers.UOffsetT(target), 0) +} +func TagEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/twt-fbs/lextwt/Text.go b/twt-fbs/lextwt/Text.go new file mode 100644 index 0000000..8cbc5f1 --- /dev/null +++ b/twt-fbs/lextwt/Text.go @@ -0,0 +1,60 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package lextwt + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +type Text struct { + _tab flatbuffers.Table +} + +func GetRootAsText(buf []byte, offset flatbuffers.UOffsetT) *Text { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &Text{} + x.Init(buf, n+offset) + return x +} + +func FinishTextBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) { + builder.Finish(offset) +} + +func GetSizePrefixedRootAsText(buf []byte, offset flatbuffers.UOffsetT) *Text { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &Text{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func FinishSizePrefixedTextBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) { + builder.FinishSizePrefixed(offset) +} + +func (rcv *Text) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *Text) Table() flatbuffers.Table { + return rcv._tab +} + +func (rcv *Text) Text() []byte { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + return rcv._tab.ByteVector(o + rcv._tab.Pos) + } + return nil +} + +func TextStart(builder *flatbuffers.Builder) { + builder.StartObject(1) +} +func TextAddText(builder *flatbuffers.Builder, text flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(text), 0) +} +func TextEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/twt-fbs/lextwt/Twt.go b/twt-fbs/lextwt/Twt.go new file mode 100644 index 0000000..e9c949a --- /dev/null +++ b/twt-fbs/lextwt/Twt.go @@ -0,0 +1,107 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package lextwt + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +type Twt struct { + _tab flatbuffers.Table +} + +func GetRootAsTwt(buf []byte, offset flatbuffers.UOffsetT) *Twt { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &Twt{} + x.Init(buf, n+offset) + return x +} + +func FinishTwtBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) { + builder.Finish(offset) +} + +func GetSizePrefixedRootAsTwt(buf []byte, offset flatbuffers.UOffsetT) *Twt { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &Twt{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func FinishSizePrefixedTwtBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) { + builder.FinishSizePrefixed(offset) +} + +func (rcv *Twt) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *Twt) Table() flatbuffers.Table { + return rcv._tab +} + +func (rcv *Twt) Twter(obj *Twter) *Twter { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + x := rcv._tab.Indirect(o + rcv._tab.Pos) + if obj == nil { + obj = new(Twter) + } + obj.Init(rcv._tab.Bytes, x) + return obj + } + return nil +} + +func (rcv *Twt) Created(obj *DateTime) *DateTime { + o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) + if o != 0 { + x := rcv._tab.Indirect(o + rcv._tab.Pos) + if obj == nil { + obj = new(DateTime) + } + obj.Init(rcv._tab.Bytes, x) + return obj + } + return nil +} + +func (rcv *Twt) Msg(obj *Msg, j int) bool { + o := flatbuffers.UOffsetT(rcv._tab.Offset(8)) + if o != 0 { + x := rcv._tab.Vector(o) + x += flatbuffers.UOffsetT(j) * 4 + x = rcv._tab.Indirect(x) + obj.Init(rcv._tab.Bytes, x) + return true + } + return false +} + +func (rcv *Twt) MsgLength() int { + o := flatbuffers.UOffsetT(rcv._tab.Offset(8)) + if o != 0 { + return rcv._tab.VectorLen(o) + } + return 0 +} + +func TwtStart(builder *flatbuffers.Builder) { + builder.StartObject(3) +} +func TwtAddTwter(builder *flatbuffers.Builder, twter flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(twter), 0) +} +func TwtAddCreated(builder *flatbuffers.Builder, created flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(1, flatbuffers.UOffsetT(created), 0) +} +func TwtAddMsg(builder *flatbuffers.Builder, msg flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(2, flatbuffers.UOffsetT(msg), 0) +} +func TwtStartMsgVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT { + return builder.StartVector(4, numElems, 4) +} +func TwtEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/twt-fbs/lextwt/TwtRegistry.go b/twt-fbs/lextwt/TwtRegistry.go new file mode 100644 index 0000000..9190193 --- /dev/null +++ b/twt-fbs/lextwt/TwtRegistry.go @@ -0,0 +1,127 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package lextwt + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +type TwtRegistry struct { + _tab flatbuffers.Table +} + +func GetRootAsTwtRegistry(buf []byte, offset flatbuffers.UOffsetT) *TwtRegistry { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &TwtRegistry{} + x.Init(buf, n+offset) + return x +} + +func FinishTwtRegistryBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) { + builder.Finish(offset) +} + +func GetSizePrefixedRootAsTwtRegistry(buf []byte, offset flatbuffers.UOffsetT) *TwtRegistry { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &TwtRegistry{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func FinishSizePrefixedTwtRegistryBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) { + builder.FinishSizePrefixed(offset) +} + +func (rcv *TwtRegistry) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *TwtRegistry) Table() flatbuffers.Table { + return rcv._tab +} + +func (rcv *TwtRegistry) Preamble(obj *Comment, j int) bool { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + x := rcv._tab.Vector(o) + x += flatbuffers.UOffsetT(j) * 4 + x = rcv._tab.Indirect(x) + obj.Init(rcv._tab.Bytes, x) + return true + } + return false +} + +func (rcv *TwtRegistry) PreambleLength() int { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + return rcv._tab.VectorLen(o) + } + return 0 +} + +func (rcv *TwtRegistry) Twters(obj *Twter, j int) bool { + o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) + if o != 0 { + x := rcv._tab.Vector(o) + x += flatbuffers.UOffsetT(j) * 4 + x = rcv._tab.Indirect(x) + obj.Init(rcv._tab.Bytes, x) + return true + } + return false +} + +func (rcv *TwtRegistry) TwtersLength() int { + o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) + if o != 0 { + return rcv._tab.VectorLen(o) + } + return 0 +} + +func (rcv *TwtRegistry) Twts(obj *Twt, j int) bool { + o := flatbuffers.UOffsetT(rcv._tab.Offset(8)) + if o != 0 { + x := rcv._tab.Vector(o) + x += flatbuffers.UOffsetT(j) * 4 + x = rcv._tab.Indirect(x) + obj.Init(rcv._tab.Bytes, x) + return true + } + return false +} + +func (rcv *TwtRegistry) TwtsLength() int { + o := flatbuffers.UOffsetT(rcv._tab.Offset(8)) + if o != 0 { + return rcv._tab.VectorLen(o) + } + return 0 +} + +func TwtRegistryStart(builder *flatbuffers.Builder) { + builder.StartObject(3) +} +func TwtRegistryAddPreamble(builder *flatbuffers.Builder, preamble flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(preamble), 0) +} +func TwtRegistryStartPreambleVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT { + return builder.StartVector(4, numElems, 4) +} +func TwtRegistryAddTwters(builder *flatbuffers.Builder, twters flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(1, flatbuffers.UOffsetT(twters), 0) +} +func TwtRegistryStartTwtersVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT { + return builder.StartVector(4, numElems, 4) +} +func TwtRegistryAddTwts(builder *flatbuffers.Builder, twts flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(2, flatbuffers.UOffsetT(twts), 0) +} +func TwtRegistryStartTwtsVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT { + return builder.StartVector(4, numElems, 4) +} +func TwtRegistryEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/twt-fbs/lextwt/Twter.go b/twt-fbs/lextwt/Twter.go new file mode 100644 index 0000000..43ace52 --- /dev/null +++ b/twt-fbs/lextwt/Twter.go @@ -0,0 +1,71 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package lextwt + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +type Twter struct { + _tab flatbuffers.Table +} + +func GetRootAsTwter(buf []byte, offset flatbuffers.UOffsetT) *Twter { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &Twter{} + x.Init(buf, n+offset) + return x +} + +func FinishTwterBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) { + builder.Finish(offset) +} + +func GetSizePrefixedRootAsTwter(buf []byte, offset flatbuffers.UOffsetT) *Twter { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &Twter{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func FinishSizePrefixedTwterBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) { + builder.FinishSizePrefixed(offset) +} + +func (rcv *Twter) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *Twter) Table() flatbuffers.Table { + return rcv._tab +} + +func (rcv *Twter) Nick() []byte { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + return rcv._tab.ByteVector(o + rcv._tab.Pos) + } + return nil +} + +func (rcv *Twter) Uri() []byte { + o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) + if o != 0 { + return rcv._tab.ByteVector(o + rcv._tab.Pos) + } + return nil +} + +func TwterStart(builder *flatbuffers.Builder) { + builder.StartObject(2) +} +func TwterAddNick(builder *flatbuffers.Builder, nick flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(nick), 0) +} +func TwterAddUri(builder *flatbuffers.Builder, uri flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(1, flatbuffers.UOffsetT(uri), 0) +} +func TwterEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +}