chore: add flatbuffers support

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 )

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()))
+}

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

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()
+}

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()
+}

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) + ")"
+}

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()
+}

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()
+}

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) + ")"
+}

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()
+}

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()
+}

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) + ")"
+}

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()
+}

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()
+}

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()
+}

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()
+}

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()
+}

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()
+}

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()
+}

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()
+}