feat(itr): add FlatBuffers binary codec for ITR command protocol
Add zero-copy binary serialization for ToolRequest/ToolResponse using FlatBuffers. The codec provides Marshal/Unmarshal methods on domain types that produce/consume the same wire format across in-process channels, Unix sockets, and WASM host calls. - Update commands.fbs with CmdType enum, DAGNode/DAGPlan tables, ToolSearch/CodeExec commands - Generate Go types in pkg/itr/itrfb/ - Implement bidirectional conversion in fb_codec.go
This commit is contained in:
ZanzyTHEbar
parent
05457ff528
commit
c86f4a53de
18 changed files with 2334 additions and 39 deletions
|
|
@ -1,72 +1,96 @@
|
|||
// PicoClaw Isolated Tool Runtime — Command Protocol
|
||||
// Namespace: picoclaw.itr
|
||||
// Namespace: itrfb (FlatBuffers generated types)
|
||||
//
|
||||
// This schema defines the binary command protocol between the agent loop
|
||||
// and the SecureBus. All tool invocations, including RLM recursive
|
||||
// decomposition operations, are serialized using this schema.
|
||||
//
|
||||
// Generated Go code lives in commands_generated.go (committed).
|
||||
// To regenerate: flatc --go --gen-mutable -o pkg/itr pkg/itr/commands.fbs
|
||||
// To regenerate: flatc --go -o pkg/itr pkg/itr/commands.fbs
|
||||
//
|
||||
// FlatBuffers provides:
|
||||
// - Zero-copy reads (no deserialization on the hot path)
|
||||
// - Schema-enforced vocabulary (LLM cannot construct out-of-vocab requests)
|
||||
// - Single binary format across all transports (channel, socket, WASM)
|
||||
|
||||
namespace picoclaw.itr;
|
||||
namespace itrfb;
|
||||
|
||||
// ── Command type discriminator ──────────────────────────────────────────────
|
||||
// Mirrors Go CommandType string constants as a numeric enum for wire encoding.
|
||||
|
||||
enum CmdType : byte {
|
||||
NONE = 0,
|
||||
Peek = 1,
|
||||
Grep = 2,
|
||||
Partition = 3,
|
||||
Recurse = 4,
|
||||
ToolExec = 5,
|
||||
ExecWasm = 6,
|
||||
Final = 7,
|
||||
ToolSearch = 8,
|
||||
CodeExec = 9,
|
||||
DAGPlan = 10
|
||||
}
|
||||
|
||||
// ── RLM Decomposition Operations ────────────────────────────────────────────
|
||||
|
||||
// Peek reads a byte range from the context rope.
|
||||
table Peek {
|
||||
start: uint64; // byte offset
|
||||
length: uint32; // bytes to read (0 = to end)
|
||||
start: uint64;
|
||||
length: uint32;
|
||||
}
|
||||
|
||||
// Grep searches the context for a pattern.
|
||||
table Grep {
|
||||
pattern: string (required);
|
||||
max_matches: uint32 = 50;
|
||||
case_insensitive: bool = false;
|
||||
}
|
||||
|
||||
// Partition splits the context into k roughly-equal chunks.
|
||||
table Partition {
|
||||
k: uint32 = 4; // number of partitions
|
||||
method: string = "uniform"; // "uniform" | "semantic"
|
||||
overlap: uint32 = 0; // token overlap between partitions
|
||||
semantic: bool = false; // use semantic boundaries (sentence/paragraph)
|
||||
k: uint32 = 4;
|
||||
method: string;
|
||||
overlap: uint32 = 0;
|
||||
semantic: bool = false;
|
||||
}
|
||||
|
||||
// Recurse spawns a sub-RLM call over a context partition.
|
||||
table Recurse {
|
||||
sub_query: string (required); // the question to answer over the partition
|
||||
context_key: string (required); // identifies which partition to use
|
||||
depth_hint: uint8 = 3; // max recursion depth
|
||||
sub_query: string (required);
|
||||
context_key: string (required);
|
||||
depth_hint: uint8 = 3;
|
||||
}
|
||||
|
||||
// ── Traditional Tool Execution ───────────────────────────────────────────────
|
||||
// ── Traditional Tool Execution ──────────────────────────────────────────────
|
||||
|
||||
// ToolExec invokes a named tool with JSON-serialized arguments.
|
||||
table ToolExec {
|
||||
tool_name: string (required);
|
||||
args_json: string (required); // JSON object
|
||||
args_json: string (required);
|
||||
}
|
||||
|
||||
// ExecWasm runs a WASM module (Layer 5 — optional, wazero isolate).
|
||||
table ExecWasm {
|
||||
module_key: string (required); // key into the WASM module registry
|
||||
entry: string (required); // exported function name
|
||||
input_json: string; // JSON input for the module
|
||||
module_key: string (required);
|
||||
entry: string (required);
|
||||
input_json: string;
|
||||
}
|
||||
|
||||
// Final records the terminal answer from an RLM recursion.
|
||||
table Final {
|
||||
answer: string (required);
|
||||
var_name: string; // optional variable name for multi-part answers
|
||||
var_name: string;
|
||||
}
|
||||
|
||||
// ── Envelope ─────────────────────────────────────────────────────────────────
|
||||
// ── Extended Commands ───────────────────────────────────────────────────────
|
||||
|
||||
table ToolSearch {
|
||||
query: string (required);
|
||||
max_results: uint8 = 10;
|
||||
}
|
||||
|
||||
table CodeExec {
|
||||
language: string (required);
|
||||
code: string (required);
|
||||
}
|
||||
|
||||
// ── Payload Union ───────────────────────────────────────────────────────────
|
||||
// Used inside both ToolRequest (top-level) and DAGNode (nested).
|
||||
// DAGPlan is NOT in this union to avoid circular references;
|
||||
// it is a separate field on ToolRequest.
|
||||
|
||||
union CommandPayload {
|
||||
Peek,
|
||||
|
|
@ -75,25 +99,47 @@ union CommandPayload {
|
|||
Recurse,
|
||||
ToolExec,
|
||||
ExecWasm,
|
||||
Final
|
||||
Final,
|
||||
ToolSearch,
|
||||
CodeExec
|
||||
}
|
||||
|
||||
table ToolRequest {
|
||||
id: string (required); // UUIDv7 for correlation
|
||||
// ── DAG Structures ──────────────────────────────────────────────────────────
|
||||
|
||||
table DAGNode {
|
||||
id: string (required);
|
||||
node_type: CmdType;
|
||||
payload: CommandPayload;
|
||||
timestamp: uint64; // Unix nanoseconds
|
||||
depth: uint8 = 0; // recursion depth (0 = top-level)
|
||||
session_key: string; // opaque session/conversation identifier
|
||||
tool_call_id: string; // links back to LLM tool_call.id
|
||||
depends_on: [string];
|
||||
}
|
||||
|
||||
table DAGPlan {
|
||||
nodes: [DAGNode];
|
||||
max_parallel: uint8 = 0;
|
||||
token_budget: uint32 = 0;
|
||||
joiner_query: string;
|
||||
}
|
||||
|
||||
// ── Envelope ────────────────────────────────────────────────────────────────
|
||||
|
||||
table ToolRequest {
|
||||
id: string (required);
|
||||
cmd_type: CmdType;
|
||||
payload: CommandPayload;
|
||||
dag_plan: DAGPlan;
|
||||
timestamp: uint64;
|
||||
depth: uint8 = 0;
|
||||
session_key: string;
|
||||
tool_call_id: string;
|
||||
}
|
||||
|
||||
table ToolResponse {
|
||||
id: string (required); // mirrors request id
|
||||
result: string; // JSON-serialized result
|
||||
id: string (required);
|
||||
result: string;
|
||||
is_error: bool = false;
|
||||
leak_detected: bool = false; // set when Redactor found a match
|
||||
cost_tokens: uint32 = 0; // tokens consumed (RLM operations)
|
||||
redacted_keys: [string]; // keys that were redacted, for audit
|
||||
leak_detected: bool = false;
|
||||
cost_tokens: uint32 = 0;
|
||||
redacted_keys: [string];
|
||||
}
|
||||
|
||||
root_type ToolRequest;
|
||||
|
|
|
|||
575
pkg/itr/fb_codec.go
Normal file
575
pkg/itr/fb_codec.go
Normal file
|
|
@ -0,0 +1,575 @@
|
|||
package itr
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
|
||||
flatbuffers "github.com/google/flatbuffers/go"
|
||||
"github.com/sipeed/picoclaw/pkg/itr/itrfb"
|
||||
)
|
||||
|
||||
// ── Domain ↔ FlatBuffers enum mapping ───────────────────────────────────────
|
||||
|
||||
var cmdTypeToFB = map[CommandType]itrfb.CmdType{
|
||||
CmdPeek: itrfb.CmdTypePeek,
|
||||
CmdGrep: itrfb.CmdTypeGrep,
|
||||
CmdPartition: itrfb.CmdTypePartition,
|
||||
CmdRecurse: itrfb.CmdTypeRecurse,
|
||||
CmdToolExec: itrfb.CmdTypeToolExec,
|
||||
CmdExecWasm: itrfb.CmdTypeExecWasm,
|
||||
CmdFinal: itrfb.CmdTypeFinal,
|
||||
CmdToolSearch: itrfb.CmdTypeToolSearch,
|
||||
CmdCodeExec: itrfb.CmdTypeCodeExec,
|
||||
CmdDAGPlan: itrfb.CmdTypeDAGPlan,
|
||||
}
|
||||
|
||||
var fbToCmdType = map[itrfb.CmdType]CommandType{
|
||||
itrfb.CmdTypePeek: CmdPeek,
|
||||
itrfb.CmdTypeGrep: CmdGrep,
|
||||
itrfb.CmdTypePartition: CmdPartition,
|
||||
itrfb.CmdTypeRecurse: CmdRecurse,
|
||||
itrfb.CmdTypeToolExec: CmdToolExec,
|
||||
itrfb.CmdTypeExecWasm: CmdExecWasm,
|
||||
itrfb.CmdTypeFinal: CmdFinal,
|
||||
itrfb.CmdTypeToolSearch: CmdToolSearch,
|
||||
itrfb.CmdTypeCodeExec: CmdCodeExec,
|
||||
itrfb.CmdTypeDAGPlan: CmdDAGPlan,
|
||||
}
|
||||
|
||||
// ── MarshalRequestFB ────────────────────────────────────────────────────────
|
||||
|
||||
func MarshalRequestFB(r ToolRequest) ([]byte, error) {
|
||||
b := flatbuffers.NewBuilder(512)
|
||||
|
||||
idOff := b.CreateString(r.ID)
|
||||
skOff := b.CreateString(r.SessionKey)
|
||||
tcOff := b.CreateString(r.ToolCallID)
|
||||
|
||||
fbCmdType, ok := cmdTypeToFB[r.Type]
|
||||
if !ok {
|
||||
return nil, fmt.Errorf("unknown command type: %q", r.Type)
|
||||
}
|
||||
|
||||
if r.Type == CmdDAGPlan {
|
||||
plan, ok := r.Payload.(DAGPlan)
|
||||
if !ok {
|
||||
return nil, fmt.Errorf("payload is not DAGPlan")
|
||||
}
|
||||
dagOff, err := buildDAGPlan(b, &plan)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
itrfb.ToolRequestStart(b)
|
||||
itrfb.ToolRequestAddId(b, idOff)
|
||||
itrfb.ToolRequestAddCmdType(b, fbCmdType)
|
||||
itrfb.ToolRequestAddDagPlan(b, dagOff)
|
||||
itrfb.ToolRequestAddTimestamp(b, uint64(r.Timestamp))
|
||||
itrfb.ToolRequestAddDepth(b, r.Depth)
|
||||
itrfb.ToolRequestAddSessionKey(b, skOff)
|
||||
itrfb.ToolRequestAddToolCallId(b, tcOff)
|
||||
reqOff := itrfb.ToolRequestEnd(b)
|
||||
itrfb.FinishToolRequestBuffer(b, reqOff)
|
||||
return b.FinishedBytes(), nil
|
||||
}
|
||||
|
||||
payloadType, payloadOff, err := buildPayload(b, r.Type, r.Payload)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
itrfb.ToolRequestStart(b)
|
||||
itrfb.ToolRequestAddId(b, idOff)
|
||||
itrfb.ToolRequestAddCmdType(b, fbCmdType)
|
||||
itrfb.ToolRequestAddPayloadType(b, payloadType)
|
||||
itrfb.ToolRequestAddPayload(b, payloadOff)
|
||||
itrfb.ToolRequestAddTimestamp(b, uint64(r.Timestamp))
|
||||
itrfb.ToolRequestAddDepth(b, r.Depth)
|
||||
itrfb.ToolRequestAddSessionKey(b, skOff)
|
||||
itrfb.ToolRequestAddToolCallId(b, tcOff)
|
||||
reqOff := itrfb.ToolRequestEnd(b)
|
||||
itrfb.FinishToolRequestBuffer(b, reqOff)
|
||||
return b.FinishedBytes(), nil
|
||||
}
|
||||
|
||||
// ── UnmarshalRequestFB ──────────────────────────────────────────────────────
|
||||
|
||||
func UnmarshalRequestFB(data []byte) (ToolRequest, error) {
|
||||
fb := itrfb.GetRootAsToolRequest(data, 0)
|
||||
|
||||
ct, ok := fbToCmdType[fb.CmdType()]
|
||||
if !ok {
|
||||
return ToolRequest{}, fmt.Errorf("unknown FlatBuffers CmdType: %d", fb.CmdType())
|
||||
}
|
||||
|
||||
req := ToolRequest{
|
||||
ID: string(fb.Id()),
|
||||
Type: ct,
|
||||
Timestamp: int64(fb.Timestamp()),
|
||||
Depth: fb.Depth(),
|
||||
SessionKey: string(fb.SessionKey()),
|
||||
ToolCallID: string(fb.ToolCallId()),
|
||||
}
|
||||
|
||||
if ct == CmdDAGPlan {
|
||||
fbPlan := fb.DagPlan(nil)
|
||||
if fbPlan == nil {
|
||||
return ToolRequest{}, fmt.Errorf("DAGPlan request missing dag_plan field")
|
||||
}
|
||||
plan, err := readDAGPlan(fbPlan)
|
||||
if err != nil {
|
||||
return ToolRequest{}, err
|
||||
}
|
||||
req.Payload = plan
|
||||
return req, nil
|
||||
}
|
||||
|
||||
payload, err := readPayload(fb.PayloadType(), fb)
|
||||
if err != nil {
|
||||
return ToolRequest{}, err
|
||||
}
|
||||
req.Payload = payload
|
||||
return req, nil
|
||||
}
|
||||
|
||||
// ── MarshalResponseFB ───────────────────────────────────────────────────────
|
||||
|
||||
func MarshalResponseFB(r ToolResponse) ([]byte, error) {
|
||||
b := flatbuffers.NewBuilder(256)
|
||||
|
||||
idOff := b.CreateString(r.ID)
|
||||
resultOff := b.CreateString(r.Result)
|
||||
|
||||
var keysOff flatbuffers.UOffsetT
|
||||
if len(r.RedactedKeys) > 0 {
|
||||
keyOffsets := make([]flatbuffers.UOffsetT, len(r.RedactedKeys))
|
||||
for i := len(r.RedactedKeys) - 1; i >= 0; i-- {
|
||||
keyOffsets[i] = b.CreateString(r.RedactedKeys[i])
|
||||
}
|
||||
itrfb.ToolResponseStartRedactedKeysVector(b, len(r.RedactedKeys))
|
||||
for i := len(keyOffsets) - 1; i >= 0; i-- {
|
||||
b.PrependUOffsetT(keyOffsets[i])
|
||||
}
|
||||
keysOff = b.EndVector(len(r.RedactedKeys))
|
||||
}
|
||||
|
||||
itrfb.ToolResponseStart(b)
|
||||
itrfb.ToolResponseAddId(b, idOff)
|
||||
itrfb.ToolResponseAddResult(b, resultOff)
|
||||
itrfb.ToolResponseAddIsError(b, r.IsError)
|
||||
itrfb.ToolResponseAddLeakDetected(b, r.LeakDetected)
|
||||
itrfb.ToolResponseAddCostTokens(b, r.CostTokens)
|
||||
if len(r.RedactedKeys) > 0 {
|
||||
itrfb.ToolResponseAddRedactedKeys(b, keysOff)
|
||||
}
|
||||
respOff := itrfb.ToolResponseEnd(b)
|
||||
itrfb.FinishToolResponseBuffer(b, respOff)
|
||||
return b.FinishedBytes(), nil
|
||||
}
|
||||
|
||||
// ── UnmarshalResponseFB ─────────────────────────────────────────────────────
|
||||
|
||||
func UnmarshalResponseFB(data []byte) (ToolResponse, error) {
|
||||
fb := itrfb.GetRootAsToolResponse(data, 0)
|
||||
|
||||
r := ToolResponse{
|
||||
ID: string(fb.Id()),
|
||||
Result: string(fb.Result()),
|
||||
IsError: fb.IsError(),
|
||||
LeakDetected: fb.LeakDetected(),
|
||||
CostTokens: fb.CostTokens(),
|
||||
}
|
||||
|
||||
n := fb.RedactedKeysLength()
|
||||
if n > 0 {
|
||||
r.RedactedKeys = make([]string, n)
|
||||
for i := 0; i < n; i++ {
|
||||
r.RedactedKeys[i] = string(fb.RedactedKeys(i))
|
||||
}
|
||||
}
|
||||
return r, nil
|
||||
}
|
||||
|
||||
// ── Payload builders ────────────────────────────────────────────────────────
|
||||
|
||||
func buildPayload(b *flatbuffers.Builder, ct CommandType, payload interface{}) (itrfb.CommandPayload, flatbuffers.UOffsetT, error) {
|
||||
switch ct {
|
||||
case CmdPeek:
|
||||
p, ok := payload.(Peek)
|
||||
if !ok {
|
||||
return 0, 0, fmt.Errorf("expected Peek payload, got %T", payload)
|
||||
}
|
||||
itrfb.PeekStart(b)
|
||||
itrfb.PeekAddStart(b, p.Start)
|
||||
itrfb.PeekAddLength(b, p.Length)
|
||||
return itrfb.CommandPayloadPeek, itrfb.PeekEnd(b), nil
|
||||
|
||||
case CmdGrep:
|
||||
p, ok := payload.(Grep)
|
||||
if !ok {
|
||||
return 0, 0, fmt.Errorf("expected Grep payload, got %T", payload)
|
||||
}
|
||||
pat := b.CreateString(p.Pattern)
|
||||
itrfb.GrepStart(b)
|
||||
itrfb.GrepAddPattern(b, pat)
|
||||
itrfb.GrepAddMaxMatches(b, p.MaxMatches)
|
||||
itrfb.GrepAddCaseInsensitive(b, p.CaseInsensitive)
|
||||
return itrfb.CommandPayloadGrep, itrfb.GrepEnd(b), nil
|
||||
|
||||
case CmdPartition:
|
||||
p, ok := payload.(Partition)
|
||||
if !ok {
|
||||
return 0, 0, fmt.Errorf("expected Partition payload, got %T", payload)
|
||||
}
|
||||
method := b.CreateString(p.Method)
|
||||
itrfb.PartitionStart(b)
|
||||
itrfb.PartitionAddK(b, p.K)
|
||||
itrfb.PartitionAddMethod(b, method)
|
||||
itrfb.PartitionAddOverlap(b, p.Overlap)
|
||||
itrfb.PartitionAddSemantic(b, p.Semantic)
|
||||
return itrfb.CommandPayloadPartition, itrfb.PartitionEnd(b), nil
|
||||
|
||||
case CmdRecurse:
|
||||
p, ok := payload.(Recurse)
|
||||
if !ok {
|
||||
return 0, 0, fmt.Errorf("expected Recurse payload, got %T", payload)
|
||||
}
|
||||
sq := b.CreateString(p.SubQuery)
|
||||
ck := b.CreateString(p.ContextKey)
|
||||
itrfb.RecurseStart(b)
|
||||
itrfb.RecurseAddSubQuery(b, sq)
|
||||
itrfb.RecurseAddContextKey(b, ck)
|
||||
itrfb.RecurseAddDepthHint(b, p.DepthHint)
|
||||
return itrfb.CommandPayloadRecurse, itrfb.RecurseEnd(b), nil
|
||||
|
||||
case CmdToolExec:
|
||||
p, ok := payload.(ToolExec)
|
||||
if !ok {
|
||||
return 0, 0, fmt.Errorf("expected ToolExec payload, got %T", payload)
|
||||
}
|
||||
tn := b.CreateString(p.ToolName)
|
||||
aj := b.CreateString(p.ArgsJSON)
|
||||
itrfb.ToolExecStart(b)
|
||||
itrfb.ToolExecAddToolName(b, tn)
|
||||
itrfb.ToolExecAddArgsJson(b, aj)
|
||||
return itrfb.CommandPayloadToolExec, itrfb.ToolExecEnd(b), nil
|
||||
|
||||
case CmdExecWasm:
|
||||
p, ok := payload.(ExecWasm)
|
||||
if !ok {
|
||||
return 0, 0, fmt.Errorf("expected ExecWasm payload, got %T", payload)
|
||||
}
|
||||
mk := b.CreateString(p.ModuleKey)
|
||||
en := b.CreateString(p.Entry)
|
||||
ij := b.CreateString(p.InputJSON)
|
||||
itrfb.ExecWasmStart(b)
|
||||
itrfb.ExecWasmAddModuleKey(b, mk)
|
||||
itrfb.ExecWasmAddEntry(b, en)
|
||||
itrfb.ExecWasmAddInputJson(b, ij)
|
||||
return itrfb.CommandPayloadExecWasm, itrfb.ExecWasmEnd(b), nil
|
||||
|
||||
case CmdFinal:
|
||||
p, ok := payload.(Final)
|
||||
if !ok {
|
||||
return 0, 0, fmt.Errorf("expected Final payload, got %T", payload)
|
||||
}
|
||||
ans := b.CreateString(p.Answer)
|
||||
vn := b.CreateString(p.VarName)
|
||||
itrfb.FinalStart(b)
|
||||
itrfb.FinalAddAnswer(b, ans)
|
||||
itrfb.FinalAddVarName(b, vn)
|
||||
return itrfb.CommandPayloadFinal, itrfb.FinalEnd(b), nil
|
||||
|
||||
case CmdToolSearch:
|
||||
p, ok := payload.(ToolSearch)
|
||||
if !ok {
|
||||
return 0, 0, fmt.Errorf("expected ToolSearch payload, got %T", payload)
|
||||
}
|
||||
q := b.CreateString(p.Query)
|
||||
itrfb.ToolSearchStart(b)
|
||||
itrfb.ToolSearchAddQuery(b, q)
|
||||
itrfb.ToolSearchAddMaxResults(b, p.MaxResults)
|
||||
return itrfb.CommandPayloadToolSearch, itrfb.ToolSearchEnd(b), nil
|
||||
|
||||
case CmdCodeExec:
|
||||
p, ok := payload.(CodeExec)
|
||||
if !ok {
|
||||
return 0, 0, fmt.Errorf("expected CodeExec payload, got %T", payload)
|
||||
}
|
||||
lang := b.CreateString(p.Language)
|
||||
code := b.CreateString(p.Code)
|
||||
itrfb.CodeExecStart(b)
|
||||
itrfb.CodeExecAddLanguage(b, lang)
|
||||
itrfb.CodeExecAddCode(b, code)
|
||||
return itrfb.CommandPayloadCodeExec, itrfb.CodeExecEnd(b), nil
|
||||
|
||||
default:
|
||||
return 0, 0, fmt.Errorf("cannot build FlatBuffers payload for type %q", ct)
|
||||
}
|
||||
}
|
||||
|
||||
// ── Payload readers ─────────────────────────────────────────────────────────
|
||||
|
||||
func readPayload(pt itrfb.CommandPayload, fb *itrfb.ToolRequest) (interface{}, error) {
|
||||
var tbl flatbuffers.Table
|
||||
if !fb.Payload(&tbl) {
|
||||
return nil, fmt.Errorf("missing payload in FlatBuffers ToolRequest")
|
||||
}
|
||||
|
||||
switch pt {
|
||||
case itrfb.CommandPayloadPeek:
|
||||
var p itrfb.Peek
|
||||
p.Init(tbl.Bytes, tbl.Pos)
|
||||
return Peek{Start: p.Start(), Length: p.Length()}, nil
|
||||
|
||||
case itrfb.CommandPayloadGrep:
|
||||
var p itrfb.Grep
|
||||
p.Init(tbl.Bytes, tbl.Pos)
|
||||
return Grep{
|
||||
Pattern: string(p.Pattern()),
|
||||
MaxMatches: p.MaxMatches(),
|
||||
CaseInsensitive: p.CaseInsensitive(),
|
||||
}, nil
|
||||
|
||||
case itrfb.CommandPayloadPartition:
|
||||
var p itrfb.Partition
|
||||
p.Init(tbl.Bytes, tbl.Pos)
|
||||
return Partition{
|
||||
K: p.K(),
|
||||
Method: string(p.Method()),
|
||||
Overlap: p.Overlap(),
|
||||
Semantic: p.Semantic(),
|
||||
}, nil
|
||||
|
||||
case itrfb.CommandPayloadRecurse:
|
||||
var p itrfb.Recurse
|
||||
p.Init(tbl.Bytes, tbl.Pos)
|
||||
return Recurse{
|
||||
SubQuery: string(p.SubQuery()),
|
||||
ContextKey: string(p.ContextKey()),
|
||||
DepthHint: p.DepthHint(),
|
||||
}, nil
|
||||
|
||||
case itrfb.CommandPayloadToolExec:
|
||||
var p itrfb.ToolExec
|
||||
p.Init(tbl.Bytes, tbl.Pos)
|
||||
return ToolExec{
|
||||
ToolName: string(p.ToolName()),
|
||||
ArgsJSON: string(p.ArgsJson()),
|
||||
}, nil
|
||||
|
||||
case itrfb.CommandPayloadExecWasm:
|
||||
var p itrfb.ExecWasm
|
||||
p.Init(tbl.Bytes, tbl.Pos)
|
||||
return ExecWasm{
|
||||
ModuleKey: string(p.ModuleKey()),
|
||||
Entry: string(p.Entry()),
|
||||
InputJSON: string(p.InputJson()),
|
||||
}, nil
|
||||
|
||||
case itrfb.CommandPayloadFinal:
|
||||
var p itrfb.Final
|
||||
p.Init(tbl.Bytes, tbl.Pos)
|
||||
return Final{
|
||||
Answer: string(p.Answer()),
|
||||
VarName: string(p.VarName()),
|
||||
}, nil
|
||||
|
||||
case itrfb.CommandPayloadToolSearch:
|
||||
var p itrfb.ToolSearch
|
||||
p.Init(tbl.Bytes, tbl.Pos)
|
||||
return ToolSearch{
|
||||
Query: string(p.Query()),
|
||||
MaxResults: p.MaxResults(),
|
||||
}, nil
|
||||
|
||||
case itrfb.CommandPayloadCodeExec:
|
||||
var p itrfb.CodeExec
|
||||
p.Init(tbl.Bytes, tbl.Pos)
|
||||
return CodeExec{
|
||||
Language: string(p.Language()),
|
||||
Code: string(p.Code()),
|
||||
}, nil
|
||||
|
||||
case itrfb.CommandPayloadNONE:
|
||||
return nil, nil
|
||||
|
||||
default:
|
||||
return nil, fmt.Errorf("unknown FlatBuffers payload type: %d", pt)
|
||||
}
|
||||
}
|
||||
|
||||
// ── DAGPlan builder/reader ──────────────────────────────────────────────────
|
||||
|
||||
func buildDAGPlan(b *flatbuffers.Builder, plan *DAGPlan) (flatbuffers.UOffsetT, error) {
|
||||
nodeOffsets := make([]flatbuffers.UOffsetT, len(plan.Nodes))
|
||||
for i := len(plan.Nodes) - 1; i >= 0; i-- {
|
||||
off, err := buildDAGNode(b, &plan.Nodes[i])
|
||||
if err != nil {
|
||||
return 0, fmt.Errorf("node %q: %w", plan.Nodes[i].ID, err)
|
||||
}
|
||||
nodeOffsets[i] = off
|
||||
}
|
||||
|
||||
itrfb.DAGPlanStartNodesVector(b, len(nodeOffsets))
|
||||
for i := len(nodeOffsets) - 1; i >= 0; i-- {
|
||||
b.PrependUOffsetT(nodeOffsets[i])
|
||||
}
|
||||
nodesVec := b.EndVector(len(nodeOffsets))
|
||||
|
||||
jq := b.CreateString(plan.JoinerQuery)
|
||||
|
||||
itrfb.DAGPlanStart(b)
|
||||
itrfb.DAGPlanAddNodes(b, nodesVec)
|
||||
itrfb.DAGPlanAddMaxParallel(b, plan.MaxParallel)
|
||||
itrfb.DAGPlanAddTokenBudget(b, plan.TokenBudget)
|
||||
itrfb.DAGPlanAddJoinerQuery(b, jq)
|
||||
return itrfb.DAGPlanEnd(b), nil
|
||||
}
|
||||
|
||||
func buildDAGNode(b *flatbuffers.Builder, node *DAGNode) (flatbuffers.UOffsetT, error) {
|
||||
idOff := b.CreateString(node.ID)
|
||||
|
||||
depOffsets := make([]flatbuffers.UOffsetT, len(node.DependsOn))
|
||||
for i := len(node.DependsOn) - 1; i >= 0; i-- {
|
||||
depOffsets[i] = b.CreateString(node.DependsOn[i])
|
||||
}
|
||||
var depsVec flatbuffers.UOffsetT
|
||||
if len(depOffsets) > 0 {
|
||||
itrfb.DAGNodeStartDependsOnVector(b, len(depOffsets))
|
||||
for i := len(depOffsets) - 1; i >= 0; i-- {
|
||||
b.PrependUOffsetT(depOffsets[i])
|
||||
}
|
||||
depsVec = b.EndVector(len(depOffsets))
|
||||
}
|
||||
|
||||
fbNodeType, ok := cmdTypeToFB[node.Type]
|
||||
if !ok {
|
||||
return 0, fmt.Errorf("unknown node type: %q", node.Type)
|
||||
}
|
||||
|
||||
payloadType, payloadOff, err := buildPayload(b, node.Type, node.Payload)
|
||||
if err != nil {
|
||||
return 0, err
|
||||
}
|
||||
|
||||
itrfb.DAGNodeStart(b)
|
||||
itrfb.DAGNodeAddId(b, idOff)
|
||||
itrfb.DAGNodeAddNodeType(b, fbNodeType)
|
||||
itrfb.DAGNodeAddPayloadType(b, payloadType)
|
||||
itrfb.DAGNodeAddPayload(b, payloadOff)
|
||||
if len(depOffsets) > 0 {
|
||||
itrfb.DAGNodeAddDependsOn(b, depsVec)
|
||||
}
|
||||
return itrfb.DAGNodeEnd(b), nil
|
||||
}
|
||||
|
||||
func readDAGPlan(fb *itrfb.DAGPlan) (DAGPlan, error) {
|
||||
plan := DAGPlan{
|
||||
MaxParallel: fb.MaxParallel(),
|
||||
TokenBudget: fb.TokenBudget(),
|
||||
JoinerQuery: string(fb.JoinerQuery()),
|
||||
}
|
||||
|
||||
n := fb.NodesLength()
|
||||
if n > 0 {
|
||||
plan.Nodes = make([]DAGNode, n)
|
||||
for i := 0; i < n; i++ {
|
||||
var fbNode itrfb.DAGNode
|
||||
if !fb.Nodes(&fbNode, i) {
|
||||
return DAGPlan{}, fmt.Errorf("failed to read DAG node at index %d", i)
|
||||
}
|
||||
node, err := readDAGNode(&fbNode)
|
||||
if err != nil {
|
||||
return DAGPlan{}, fmt.Errorf("node %d: %w", i, err)
|
||||
}
|
||||
plan.Nodes[i] = node
|
||||
}
|
||||
}
|
||||
return plan, nil
|
||||
}
|
||||
|
||||
func readDAGNode(fb *itrfb.DAGNode) (DAGNode, error) {
|
||||
ct, ok := fbToCmdType[itrfb.CmdType(fb.NodeType())]
|
||||
if !ok {
|
||||
return DAGNode{}, fmt.Errorf("unknown FlatBuffers node type: %d", fb.NodeType())
|
||||
}
|
||||
|
||||
node := DAGNode{
|
||||
ID: string(fb.Id()),
|
||||
Type: ct,
|
||||
}
|
||||
|
||||
ndeps := fb.DependsOnLength()
|
||||
if ndeps > 0 {
|
||||
node.DependsOn = make([]string, ndeps)
|
||||
for i := 0; i < ndeps; i++ {
|
||||
node.DependsOn[i] = string(fb.DependsOn(i))
|
||||
}
|
||||
}
|
||||
|
||||
payload, err := readNodePayload(fb.PayloadType(), fb)
|
||||
if err != nil {
|
||||
return DAGNode{}, err
|
||||
}
|
||||
node.Payload = payload
|
||||
return node, nil
|
||||
}
|
||||
|
||||
func readNodePayload(pt itrfb.CommandPayload, fb *itrfb.DAGNode) (interface{}, error) {
|
||||
var tbl flatbuffers.Table
|
||||
if !fb.Payload(&tbl) {
|
||||
return nil, nil
|
||||
}
|
||||
|
||||
switch pt {
|
||||
case itrfb.CommandPayloadPeek:
|
||||
var p itrfb.Peek
|
||||
p.Init(tbl.Bytes, tbl.Pos)
|
||||
return Peek{Start: p.Start(), Length: p.Length()}, nil
|
||||
|
||||
case itrfb.CommandPayloadGrep:
|
||||
var p itrfb.Grep
|
||||
p.Init(tbl.Bytes, tbl.Pos)
|
||||
return Grep{Pattern: string(p.Pattern()), MaxMatches: p.MaxMatches(), CaseInsensitive: p.CaseInsensitive()}, nil
|
||||
|
||||
case itrfb.CommandPayloadPartition:
|
||||
var p itrfb.Partition
|
||||
p.Init(tbl.Bytes, tbl.Pos)
|
||||
return Partition{K: p.K(), Method: string(p.Method()), Overlap: p.Overlap(), Semantic: p.Semantic()}, nil
|
||||
|
||||
case itrfb.CommandPayloadRecurse:
|
||||
var p itrfb.Recurse
|
||||
p.Init(tbl.Bytes, tbl.Pos)
|
||||
return Recurse{SubQuery: string(p.SubQuery()), ContextKey: string(p.ContextKey()), DepthHint: p.DepthHint()}, nil
|
||||
|
||||
case itrfb.CommandPayloadToolExec:
|
||||
var p itrfb.ToolExec
|
||||
p.Init(tbl.Bytes, tbl.Pos)
|
||||
return ToolExec{ToolName: string(p.ToolName()), ArgsJSON: string(p.ArgsJson())}, nil
|
||||
|
||||
case itrfb.CommandPayloadExecWasm:
|
||||
var p itrfb.ExecWasm
|
||||
p.Init(tbl.Bytes, tbl.Pos)
|
||||
return ExecWasm{ModuleKey: string(p.ModuleKey()), Entry: string(p.Entry()), InputJSON: string(p.InputJson())}, nil
|
||||
|
||||
case itrfb.CommandPayloadFinal:
|
||||
var p itrfb.Final
|
||||
p.Init(tbl.Bytes, tbl.Pos)
|
||||
return Final{Answer: string(p.Answer()), VarName: string(p.VarName())}, nil
|
||||
|
||||
case itrfb.CommandPayloadToolSearch:
|
||||
var p itrfb.ToolSearch
|
||||
p.Init(tbl.Bytes, tbl.Pos)
|
||||
return ToolSearch{Query: string(p.Query()), MaxResults: p.MaxResults()}, nil
|
||||
|
||||
case itrfb.CommandPayloadCodeExec:
|
||||
var p itrfb.CodeExec
|
||||
p.Init(tbl.Bytes, tbl.Pos)
|
||||
return CodeExec{Language: string(p.Language()), Code: string(p.Code())}, nil
|
||||
|
||||
case itrfb.CommandPayloadNONE:
|
||||
return nil, nil
|
||||
|
||||
default:
|
||||
return nil, fmt.Errorf("unknown FlatBuffers node payload type: %d", pt)
|
||||
}
|
||||
}
|
||||
285
pkg/itr/fb_codec_test.go
Normal file
285
pkg/itr/fb_codec_test.go
Normal file
|
|
@ -0,0 +1,285 @@
|
|||
package itr_test
|
||||
|
||||
import (
|
||||
"testing"
|
||||
"time"
|
||||
|
||||
"github.com/sipeed/picoclaw/pkg/itr"
|
||||
"github.com/stretchr/testify/assert"
|
||||
"github.com/stretchr/testify/require"
|
||||
)
|
||||
|
||||
func TestFBCodec_RequestRoundtrip_Peek(t *testing.T) {
|
||||
orig := itr.NewPeekRequest("req-1", "sess-A", 2, 1024, 4096)
|
||||
|
||||
data, err := itr.MarshalRequestFB(orig)
|
||||
require.NoError(t, err)
|
||||
|
||||
got, err := itr.UnmarshalRequestFB(data)
|
||||
require.NoError(t, err)
|
||||
|
||||
assert.Equal(t, orig.ID, got.ID)
|
||||
assert.Equal(t, orig.Type, got.Type)
|
||||
assert.Equal(t, orig.Depth, got.Depth)
|
||||
assert.Equal(t, orig.SessionKey, got.SessionKey)
|
||||
origP, ok := orig.Payload.(itr.Peek)
|
||||
require.True(t, ok, "orig payload should be Peek")
|
||||
gotP, ok := got.Payload.(itr.Peek)
|
||||
require.True(t, ok, "got payload should be Peek")
|
||||
assert.Equal(t, origP, gotP)
|
||||
}
|
||||
|
||||
func TestFBCodec_RequestRoundtrip_Grep(t *testing.T) {
|
||||
orig := itr.NewGrepRequest("req-2", "sess-B", 1, "error.*fatal", 25, true)
|
||||
|
||||
data, err := itr.MarshalRequestFB(orig)
|
||||
require.NoError(t, err)
|
||||
|
||||
got, err := itr.UnmarshalRequestFB(data)
|
||||
require.NoError(t, err)
|
||||
|
||||
assert.Equal(t, orig.Type, got.Type)
|
||||
p, ok := got.Payload.(itr.Grep)
|
||||
require.True(t, ok, "payload should be Grep")
|
||||
assert.Equal(t, "error.*fatal", p.Pattern)
|
||||
assert.Equal(t, uint32(25), p.MaxMatches)
|
||||
assert.True(t, p.CaseInsensitive)
|
||||
}
|
||||
|
||||
func TestFBCodec_RequestRoundtrip_Partition(t *testing.T) {
|
||||
orig := itr.NewPartitionRequest("req-3", "sess-C", 0, 8, "semantic", 100, true)
|
||||
|
||||
data, err := itr.MarshalRequestFB(orig)
|
||||
require.NoError(t, err)
|
||||
|
||||
got, err := itr.UnmarshalRequestFB(data)
|
||||
require.NoError(t, err)
|
||||
|
||||
p, ok := got.Payload.(itr.Partition)
|
||||
require.True(t, ok, "payload should be Partition")
|
||||
assert.Equal(t, uint32(8), p.K)
|
||||
assert.Equal(t, "semantic", p.Method)
|
||||
assert.Equal(t, uint32(100), p.Overlap)
|
||||
assert.True(t, p.Semantic)
|
||||
}
|
||||
|
||||
func TestFBCodec_RequestRoundtrip_Recurse(t *testing.T) {
|
||||
orig := itr.NewRecurseRequest("req-4", "sess-D", 3, "summarize this", "ctx-key-7", 5)
|
||||
|
||||
data, err := itr.MarshalRequestFB(orig)
|
||||
require.NoError(t, err)
|
||||
|
||||
got, err := itr.UnmarshalRequestFB(data)
|
||||
require.NoError(t, err)
|
||||
|
||||
p, ok := got.Payload.(itr.Recurse)
|
||||
require.True(t, ok, "payload should be Recurse")
|
||||
assert.Equal(t, "summarize this", p.SubQuery)
|
||||
assert.Equal(t, "ctx-key-7", p.ContextKey)
|
||||
assert.Equal(t, uint8(5), p.DepthHint)
|
||||
}
|
||||
|
||||
func TestFBCodec_RequestRoundtrip_ToolExec(t *testing.T) {
|
||||
orig := itr.NewToolExecRequest("req-5", "sess-E", "tc-1", "read_file", `{"path":"/etc/hosts"}`)
|
||||
|
||||
data, err := itr.MarshalRequestFB(orig)
|
||||
require.NoError(t, err)
|
||||
|
||||
got, err := itr.UnmarshalRequestFB(data)
|
||||
require.NoError(t, err)
|
||||
|
||||
p, ok := got.Payload.(itr.ToolExec)
|
||||
require.True(t, ok, "payload should be ToolExec")
|
||||
assert.Equal(t, "read_file", p.ToolName)
|
||||
assert.Equal(t, `{"path":"/etc/hosts"}`, p.ArgsJSON)
|
||||
assert.Equal(t, "tc-1", got.ToolCallID)
|
||||
}
|
||||
|
||||
func TestFBCodec_RequestRoundtrip_ExecWasm(t *testing.T) {
|
||||
orig := itr.ToolRequest{
|
||||
ID: "req-6",
|
||||
Type: itr.CmdExecWasm,
|
||||
Payload: itr.ExecWasm{ModuleKey: "mod-1", Entry: "main", InputJSON: `{"x":1}`},
|
||||
Timestamp: time.Now().UnixNano(),
|
||||
SessionKey: "sess-F",
|
||||
}
|
||||
|
||||
data, err := itr.MarshalRequestFB(orig)
|
||||
require.NoError(t, err)
|
||||
|
||||
got, err := itr.UnmarshalRequestFB(data)
|
||||
require.NoError(t, err)
|
||||
|
||||
p, ok := got.Payload.(itr.ExecWasm)
|
||||
require.True(t, ok, "payload should be ExecWasm")
|
||||
assert.Equal(t, "mod-1", p.ModuleKey)
|
||||
assert.Equal(t, "main", p.Entry)
|
||||
assert.Equal(t, `{"x":1}`, p.InputJSON)
|
||||
}
|
||||
|
||||
func TestFBCodec_RequestRoundtrip_Final(t *testing.T) {
|
||||
orig := itr.NewFinalRequest("req-7", "sess-G", 2, "The answer is 42", "ans_var")
|
||||
|
||||
data, err := itr.MarshalRequestFB(orig)
|
||||
require.NoError(t, err)
|
||||
|
||||
got, err := itr.UnmarshalRequestFB(data)
|
||||
require.NoError(t, err)
|
||||
|
||||
p, ok := got.Payload.(itr.Final)
|
||||
require.True(t, ok, "payload should be Final")
|
||||
assert.Equal(t, "The answer is 42", p.Answer)
|
||||
assert.Equal(t, "ans_var", p.VarName)
|
||||
}
|
||||
|
||||
func TestFBCodec_RequestRoundtrip_ToolSearch(t *testing.T) {
|
||||
orig := itr.NewToolSearchRequest("req-8", "sess-H", "find file tools", 5)
|
||||
|
||||
data, err := itr.MarshalRequestFB(orig)
|
||||
require.NoError(t, err)
|
||||
|
||||
got, err := itr.UnmarshalRequestFB(data)
|
||||
require.NoError(t, err)
|
||||
|
||||
p, ok := got.Payload.(itr.ToolSearch)
|
||||
require.True(t, ok, "payload should be ToolSearch")
|
||||
assert.Equal(t, "find file tools", p.Query)
|
||||
assert.Equal(t, uint8(5), p.MaxResults)
|
||||
}
|
||||
|
||||
func TestFBCodec_RequestRoundtrip_CodeExec(t *testing.T) {
|
||||
orig := itr.NewCodeExecRequest("req-9", "sess-I", "console.log('hi')", "javascript")
|
||||
|
||||
data, err := itr.MarshalRequestFB(orig)
|
||||
require.NoError(t, err)
|
||||
|
||||
got, err := itr.UnmarshalRequestFB(data)
|
||||
require.NoError(t, err)
|
||||
|
||||
p, ok := got.Payload.(itr.CodeExec)
|
||||
require.True(t, ok, "payload should be CodeExec")
|
||||
assert.Equal(t, "console.log('hi')", p.Code)
|
||||
assert.Equal(t, "javascript", p.Language)
|
||||
}
|
||||
|
||||
func TestFBCodec_RequestRoundtrip_DAGPlan(t *testing.T) {
|
||||
plan := itr.DAGPlan{
|
||||
Nodes: []itr.DAGNode{
|
||||
{
|
||||
ID: "a",
|
||||
Type: itr.CmdToolExec,
|
||||
Payload: itr.ToolExec{ToolName: "read_file", ArgsJSON: `{"path":"x.txt"}`},
|
||||
},
|
||||
{
|
||||
ID: "b",
|
||||
Type: itr.CmdToolSearch,
|
||||
Payload: itr.ToolSearch{Query: "search tools", MaxResults: 3},
|
||||
DependsOn: []string{"a"},
|
||||
},
|
||||
},
|
||||
MaxParallel: 4,
|
||||
TokenBudget: 10000,
|
||||
JoinerQuery: "Summarize the results",
|
||||
}
|
||||
orig := itr.NewDAGPlanRequest("req-10", "sess-J", plan)
|
||||
|
||||
data, err := itr.MarshalRequestFB(orig)
|
||||
require.NoError(t, err)
|
||||
|
||||
got, err := itr.UnmarshalRequestFB(data)
|
||||
require.NoError(t, err)
|
||||
|
||||
assert.Equal(t, itr.CmdDAGPlan, got.Type)
|
||||
|
||||
gotPlan, ok := got.Payload.(itr.DAGPlan)
|
||||
require.True(t, ok)
|
||||
|
||||
assert.Equal(t, uint8(4), gotPlan.MaxParallel)
|
||||
assert.Equal(t, uint32(10000), gotPlan.TokenBudget)
|
||||
assert.Equal(t, "Summarize the results", gotPlan.JoinerQuery)
|
||||
require.Len(t, gotPlan.Nodes, 2)
|
||||
|
||||
nodeA := gotPlan.Nodes[0]
|
||||
assert.Equal(t, "a", nodeA.ID)
|
||||
assert.Equal(t, itr.CmdToolExec, nodeA.Type)
|
||||
te, ok := nodeA.Payload.(itr.ToolExec)
|
||||
require.True(t, ok)
|
||||
assert.Equal(t, "read_file", te.ToolName)
|
||||
assert.Equal(t, `{"path":"x.txt"}`, te.ArgsJSON)
|
||||
|
||||
nodeB := gotPlan.Nodes[1]
|
||||
assert.Equal(t, "b", nodeB.ID)
|
||||
assert.Equal(t, itr.CmdToolSearch, nodeB.Type)
|
||||
ts, ok := nodeB.Payload.(itr.ToolSearch)
|
||||
require.True(t, ok)
|
||||
assert.Equal(t, "search tools", ts.Query)
|
||||
assert.Equal(t, uint8(3), ts.MaxResults)
|
||||
assert.Equal(t, []string{"a"}, nodeB.DependsOn)
|
||||
}
|
||||
|
||||
func TestFBCodec_ResponseRoundtrip_Success(t *testing.T) {
|
||||
orig := itr.NewSuccessResponse("resp-1", "file contents here", 150)
|
||||
|
||||
data, err := itr.MarshalResponseFB(orig)
|
||||
require.NoError(t, err)
|
||||
|
||||
got, err := itr.UnmarshalResponseFB(data)
|
||||
require.NoError(t, err)
|
||||
|
||||
assert.Equal(t, "resp-1", got.ID)
|
||||
assert.Equal(t, "file contents here", got.Result)
|
||||
assert.False(t, got.IsError)
|
||||
assert.Equal(t, uint32(150), got.CostTokens)
|
||||
}
|
||||
|
||||
func TestFBCodec_ResponseRoundtrip_Error(t *testing.T) {
|
||||
orig := itr.NewErrorResponse("resp-2", "tool not found")
|
||||
|
||||
data, err := itr.MarshalResponseFB(orig)
|
||||
require.NoError(t, err)
|
||||
|
||||
got, err := itr.UnmarshalResponseFB(data)
|
||||
require.NoError(t, err)
|
||||
|
||||
assert.True(t, got.IsError)
|
||||
assert.Equal(t, "tool not found", got.Result)
|
||||
}
|
||||
|
||||
func TestFBCodec_ResponseRoundtrip_Leak(t *testing.T) {
|
||||
orig := itr.NewLeakResponse("resp-3", "redacted output", []string{"api_key", "password"})
|
||||
|
||||
data, err := itr.MarshalResponseFB(orig)
|
||||
require.NoError(t, err)
|
||||
|
||||
got, err := itr.UnmarshalResponseFB(data)
|
||||
require.NoError(t, err)
|
||||
|
||||
assert.True(t, got.LeakDetected)
|
||||
assert.Equal(t, []string{"api_key", "password"}, got.RedactedKeys)
|
||||
}
|
||||
|
||||
func TestFBCodec_TimestampPreserved(t *testing.T) {
|
||||
ts := time.Now().UnixNano()
|
||||
orig := itr.ToolRequest{
|
||||
ID: "ts-test",
|
||||
Type: itr.CmdPeek,
|
||||
Payload: itr.Peek{Start: 0, Length: 10},
|
||||
Timestamp: ts,
|
||||
}
|
||||
|
||||
data, err := itr.MarshalRequestFB(orig)
|
||||
require.NoError(t, err)
|
||||
|
||||
got, err := itr.UnmarshalRequestFB(data)
|
||||
require.NoError(t, err)
|
||||
|
||||
assert.Equal(t, ts, got.Timestamp)
|
||||
}
|
||||
|
||||
func TestFBCodec_UnknownCommandType(t *testing.T) {
|
||||
_, err := itr.MarshalRequestFB(itr.ToolRequest{
|
||||
ID: "bad",
|
||||
Type: itr.CommandType("nonexistent"),
|
||||
})
|
||||
assert.Error(t, err)
|
||||
}
|
||||
56
pkg/itr/itrfb/CmdType.go
Normal file
56
pkg/itr/itrfb/CmdType.go
Normal file
|
|
@ -0,0 +1,56 @@
|
|||
// Code generated by the FlatBuffers compiler. DO NOT EDIT.
|
||||
|
||||
package itrfb
|
||||
|
||||
import "strconv"
|
||||
|
||||
type CmdType int8
|
||||
|
||||
const (
|
||||
CmdTypeNONE CmdType = 0
|
||||
CmdTypePeek CmdType = 1
|
||||
CmdTypeGrep CmdType = 2
|
||||
CmdTypePartition CmdType = 3
|
||||
CmdTypeRecurse CmdType = 4
|
||||
CmdTypeToolExec CmdType = 5
|
||||
CmdTypeExecWasm CmdType = 6
|
||||
CmdTypeFinal CmdType = 7
|
||||
CmdTypeToolSearch CmdType = 8
|
||||
CmdTypeCodeExec CmdType = 9
|
||||
CmdTypeDAGPlan CmdType = 10
|
||||
)
|
||||
|
||||
var EnumNamesCmdType = map[CmdType]string{
|
||||
CmdTypeNONE: "NONE",
|
||||
CmdTypePeek: "Peek",
|
||||
CmdTypeGrep: "Grep",
|
||||
CmdTypePartition: "Partition",
|
||||
CmdTypeRecurse: "Recurse",
|
||||
CmdTypeToolExec: "ToolExec",
|
||||
CmdTypeExecWasm: "ExecWasm",
|
||||
CmdTypeFinal: "Final",
|
||||
CmdTypeToolSearch: "ToolSearch",
|
||||
CmdTypeCodeExec: "CodeExec",
|
||||
CmdTypeDAGPlan: "DAGPlan",
|
||||
}
|
||||
|
||||
var EnumValuesCmdType = map[string]CmdType{
|
||||
"NONE": CmdTypeNONE,
|
||||
"Peek": CmdTypePeek,
|
||||
"Grep": CmdTypeGrep,
|
||||
"Partition": CmdTypePartition,
|
||||
"Recurse": CmdTypeRecurse,
|
||||
"ToolExec": CmdTypeToolExec,
|
||||
"ExecWasm": CmdTypeExecWasm,
|
||||
"Final": CmdTypeFinal,
|
||||
"ToolSearch": CmdTypeToolSearch,
|
||||
"CodeExec": CmdTypeCodeExec,
|
||||
"DAGPlan": CmdTypeDAGPlan,
|
||||
}
|
||||
|
||||
func (v CmdType) String() string {
|
||||
if s, ok := EnumNamesCmdType[v]; ok {
|
||||
return s
|
||||
}
|
||||
return "CmdType(" + strconv.FormatInt(int64(v), 10) + ")"
|
||||
}
|
||||
71
pkg/itr/itrfb/CodeExec.go
Normal file
71
pkg/itr/itrfb/CodeExec.go
Normal file
|
|
@ -0,0 +1,71 @@
|
|||
// Code generated by the FlatBuffers compiler. DO NOT EDIT.
|
||||
|
||||
package itrfb
|
||||
|
||||
import (
|
||||
flatbuffers "github.com/google/flatbuffers/go"
|
||||
)
|
||||
|
||||
type CodeExec struct {
|
||||
_tab flatbuffers.Table
|
||||
}
|
||||
|
||||
func GetRootAsCodeExec(buf []byte, offset flatbuffers.UOffsetT) *CodeExec {
|
||||
n := flatbuffers.GetUOffsetT(buf[offset:])
|
||||
x := &CodeExec{}
|
||||
x.Init(buf, n+offset)
|
||||
return x
|
||||
}
|
||||
|
||||
func FinishCodeExecBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
|
||||
builder.Finish(offset)
|
||||
}
|
||||
|
||||
func GetSizePrefixedRootAsCodeExec(buf []byte, offset flatbuffers.UOffsetT) *CodeExec {
|
||||
n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:])
|
||||
x := &CodeExec{}
|
||||
x.Init(buf, n+offset+flatbuffers.SizeUint32)
|
||||
return x
|
||||
}
|
||||
|
||||
func FinishSizePrefixedCodeExecBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
|
||||
builder.FinishSizePrefixed(offset)
|
||||
}
|
||||
|
||||
func (rcv *CodeExec) Init(buf []byte, i flatbuffers.UOffsetT) {
|
||||
rcv._tab.Bytes = buf
|
||||
rcv._tab.Pos = i
|
||||
}
|
||||
|
||||
func (rcv *CodeExec) Table() flatbuffers.Table {
|
||||
return rcv._tab
|
||||
}
|
||||
|
||||
func (rcv *CodeExec) Language() []byte {
|
||||
o := flatbuffers.UOffsetT(rcv._tab.Offset(4))
|
||||
if o != 0 {
|
||||
return rcv._tab.ByteVector(o + rcv._tab.Pos)
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func (rcv *CodeExec) Code() []byte {
|
||||
o := flatbuffers.UOffsetT(rcv._tab.Offset(6))
|
||||
if o != 0 {
|
||||
return rcv._tab.ByteVector(o + rcv._tab.Pos)
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func CodeExecStart(builder *flatbuffers.Builder) {
|
||||
builder.StartObject(2)
|
||||
}
|
||||
func CodeExecAddLanguage(builder *flatbuffers.Builder, language flatbuffers.UOffsetT) {
|
||||
builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(language), 0)
|
||||
}
|
||||
func CodeExecAddCode(builder *flatbuffers.Builder, code flatbuffers.UOffsetT) {
|
||||
builder.PrependUOffsetTSlot(1, flatbuffers.UOffsetT(code), 0)
|
||||
}
|
||||
func CodeExecEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
|
||||
return builder.EndObject()
|
||||
}
|
||||
53
pkg/itr/itrfb/CommandPayload.go
Normal file
53
pkg/itr/itrfb/CommandPayload.go
Normal file
|
|
@ -0,0 +1,53 @@
|
|||
// Code generated by the FlatBuffers compiler. DO NOT EDIT.
|
||||
|
||||
package itrfb
|
||||
|
||||
import "strconv"
|
||||
|
||||
type CommandPayload byte
|
||||
|
||||
const (
|
||||
CommandPayloadNONE CommandPayload = 0
|
||||
CommandPayloadPeek CommandPayload = 1
|
||||
CommandPayloadGrep CommandPayload = 2
|
||||
CommandPayloadPartition CommandPayload = 3
|
||||
CommandPayloadRecurse CommandPayload = 4
|
||||
CommandPayloadToolExec CommandPayload = 5
|
||||
CommandPayloadExecWasm CommandPayload = 6
|
||||
CommandPayloadFinal CommandPayload = 7
|
||||
CommandPayloadToolSearch CommandPayload = 8
|
||||
CommandPayloadCodeExec CommandPayload = 9
|
||||
)
|
||||
|
||||
var EnumNamesCommandPayload = map[CommandPayload]string{
|
||||
CommandPayloadNONE: "NONE",
|
||||
CommandPayloadPeek: "Peek",
|
||||
CommandPayloadGrep: "Grep",
|
||||
CommandPayloadPartition: "Partition",
|
||||
CommandPayloadRecurse: "Recurse",
|
||||
CommandPayloadToolExec: "ToolExec",
|
||||
CommandPayloadExecWasm: "ExecWasm",
|
||||
CommandPayloadFinal: "Final",
|
||||
CommandPayloadToolSearch: "ToolSearch",
|
||||
CommandPayloadCodeExec: "CodeExec",
|
||||
}
|
||||
|
||||
var EnumValuesCommandPayload = map[string]CommandPayload{
|
||||
"NONE": CommandPayloadNONE,
|
||||
"Peek": CommandPayloadPeek,
|
||||
"Grep": CommandPayloadGrep,
|
||||
"Partition": CommandPayloadPartition,
|
||||
"Recurse": CommandPayloadRecurse,
|
||||
"ToolExec": CommandPayloadToolExec,
|
||||
"ExecWasm": CommandPayloadExecWasm,
|
||||
"Final": CommandPayloadFinal,
|
||||
"ToolSearch": CommandPayloadToolSearch,
|
||||
"CodeExec": CommandPayloadCodeExec,
|
||||
}
|
||||
|
||||
func (v CommandPayload) String() string {
|
||||
if s, ok := EnumNamesCommandPayload[v]; ok {
|
||||
return s
|
||||
}
|
||||
return "CommandPayload(" + strconv.FormatInt(int64(v), 10) + ")"
|
||||
}
|
||||
125
pkg/itr/itrfb/DAGNode.go
Normal file
125
pkg/itr/itrfb/DAGNode.go
Normal file
|
|
@ -0,0 +1,125 @@
|
|||
// Code generated by the FlatBuffers compiler. DO NOT EDIT.
|
||||
|
||||
package itrfb
|
||||
|
||||
import (
|
||||
flatbuffers "github.com/google/flatbuffers/go"
|
||||
)
|
||||
|
||||
type DAGNode struct {
|
||||
_tab flatbuffers.Table
|
||||
}
|
||||
|
||||
func GetRootAsDAGNode(buf []byte, offset flatbuffers.UOffsetT) *DAGNode {
|
||||
n := flatbuffers.GetUOffsetT(buf[offset:])
|
||||
x := &DAGNode{}
|
||||
x.Init(buf, n+offset)
|
||||
return x
|
||||
}
|
||||
|
||||
func FinishDAGNodeBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
|
||||
builder.Finish(offset)
|
||||
}
|
||||
|
||||
func GetSizePrefixedRootAsDAGNode(buf []byte, offset flatbuffers.UOffsetT) *DAGNode {
|
||||
n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:])
|
||||
x := &DAGNode{}
|
||||
x.Init(buf, n+offset+flatbuffers.SizeUint32)
|
||||
return x
|
||||
}
|
||||
|
||||
func FinishSizePrefixedDAGNodeBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
|
||||
builder.FinishSizePrefixed(offset)
|
||||
}
|
||||
|
||||
func (rcv *DAGNode) Init(buf []byte, i flatbuffers.UOffsetT) {
|
||||
rcv._tab.Bytes = buf
|
||||
rcv._tab.Pos = i
|
||||
}
|
||||
|
||||
func (rcv *DAGNode) Table() flatbuffers.Table {
|
||||
return rcv._tab
|
||||
}
|
||||
|
||||
func (rcv *DAGNode) Id() []byte {
|
||||
o := flatbuffers.UOffsetT(rcv._tab.Offset(4))
|
||||
if o != 0 {
|
||||
return rcv._tab.ByteVector(o + rcv._tab.Pos)
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func (rcv *DAGNode) NodeType() CmdType {
|
||||
o := flatbuffers.UOffsetT(rcv._tab.Offset(6))
|
||||
if o != 0 {
|
||||
return CmdType(rcv._tab.GetInt8(o + rcv._tab.Pos))
|
||||
}
|
||||
return 0
|
||||
}
|
||||
|
||||
func (rcv *DAGNode) MutateNodeType(n CmdType) bool {
|
||||
return rcv._tab.MutateInt8Slot(6, int8(n))
|
||||
}
|
||||
|
||||
func (rcv *DAGNode) PayloadType() CommandPayload {
|
||||
o := flatbuffers.UOffsetT(rcv._tab.Offset(8))
|
||||
if o != 0 {
|
||||
return CommandPayload(rcv._tab.GetByte(o + rcv._tab.Pos))
|
||||
}
|
||||
return 0
|
||||
}
|
||||
|
||||
func (rcv *DAGNode) MutatePayloadType(n CommandPayload) bool {
|
||||
return rcv._tab.MutateByteSlot(8, byte(n))
|
||||
}
|
||||
|
||||
func (rcv *DAGNode) Payload(obj *flatbuffers.Table) bool {
|
||||
o := flatbuffers.UOffsetT(rcv._tab.Offset(10))
|
||||
if o != 0 {
|
||||
rcv._tab.Union(obj, o)
|
||||
return true
|
||||
}
|
||||
return false
|
||||
}
|
||||
|
||||
func (rcv *DAGNode) DependsOn(j int) []byte {
|
||||
o := flatbuffers.UOffsetT(rcv._tab.Offset(12))
|
||||
if o != 0 {
|
||||
a := rcv._tab.Vector(o)
|
||||
return rcv._tab.ByteVector(a + flatbuffers.UOffsetT(j*4))
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func (rcv *DAGNode) DependsOnLength() int {
|
||||
o := flatbuffers.UOffsetT(rcv._tab.Offset(12))
|
||||
if o != 0 {
|
||||
return rcv._tab.VectorLen(o)
|
||||
}
|
||||
return 0
|
||||
}
|
||||
|
||||
func DAGNodeStart(builder *flatbuffers.Builder) {
|
||||
builder.StartObject(5)
|
||||
}
|
||||
func DAGNodeAddId(builder *flatbuffers.Builder, id flatbuffers.UOffsetT) {
|
||||
builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(id), 0)
|
||||
}
|
||||
func DAGNodeAddNodeType(builder *flatbuffers.Builder, nodeType CmdType) {
|
||||
builder.PrependInt8Slot(1, int8(nodeType), 0)
|
||||
}
|
||||
func DAGNodeAddPayloadType(builder *flatbuffers.Builder, payloadType CommandPayload) {
|
||||
builder.PrependByteSlot(2, byte(payloadType), 0)
|
||||
}
|
||||
func DAGNodeAddPayload(builder *flatbuffers.Builder, payload flatbuffers.UOffsetT) {
|
||||
builder.PrependUOffsetTSlot(3, flatbuffers.UOffsetT(payload), 0)
|
||||
}
|
||||
func DAGNodeAddDependsOn(builder *flatbuffers.Builder, dependsOn flatbuffers.UOffsetT) {
|
||||
builder.PrependUOffsetTSlot(4, flatbuffers.UOffsetT(dependsOn), 0)
|
||||
}
|
||||
func DAGNodeStartDependsOnVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT {
|
||||
return builder.StartVector(4, numElems, 4)
|
||||
}
|
||||
func DAGNodeEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
|
||||
return builder.EndObject()
|
||||
}
|
||||
116
pkg/itr/itrfb/DAGPlan.go
Normal file
116
pkg/itr/itrfb/DAGPlan.go
Normal file
|
|
@ -0,0 +1,116 @@
|
|||
// Code generated by the FlatBuffers compiler. DO NOT EDIT.
|
||||
|
||||
package itrfb
|
||||
|
||||
import (
|
||||
flatbuffers "github.com/google/flatbuffers/go"
|
||||
)
|
||||
|
||||
type DAGPlan struct {
|
||||
_tab flatbuffers.Table
|
||||
}
|
||||
|
||||
func GetRootAsDAGPlan(buf []byte, offset flatbuffers.UOffsetT) *DAGPlan {
|
||||
n := flatbuffers.GetUOffsetT(buf[offset:])
|
||||
x := &DAGPlan{}
|
||||
x.Init(buf, n+offset)
|
||||
return x
|
||||
}
|
||||
|
||||
func FinishDAGPlanBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
|
||||
builder.Finish(offset)
|
||||
}
|
||||
|
||||
func GetSizePrefixedRootAsDAGPlan(buf []byte, offset flatbuffers.UOffsetT) *DAGPlan {
|
||||
n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:])
|
||||
x := &DAGPlan{}
|
||||
x.Init(buf, n+offset+flatbuffers.SizeUint32)
|
||||
return x
|
||||
}
|
||||
|
||||
func FinishSizePrefixedDAGPlanBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
|
||||
builder.FinishSizePrefixed(offset)
|
||||
}
|
||||
|
||||
func (rcv *DAGPlan) Init(buf []byte, i flatbuffers.UOffsetT) {
|
||||
rcv._tab.Bytes = buf
|
||||
rcv._tab.Pos = i
|
||||
}
|
||||
|
||||
func (rcv *DAGPlan) Table() flatbuffers.Table {
|
||||
return rcv._tab
|
||||
}
|
||||
|
||||
func (rcv *DAGPlan) Nodes(obj *DAGNode, 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 *DAGPlan) NodesLength() int {
|
||||
o := flatbuffers.UOffsetT(rcv._tab.Offset(4))
|
||||
if o != 0 {
|
||||
return rcv._tab.VectorLen(o)
|
||||
}
|
||||
return 0
|
||||
}
|
||||
|
||||
func (rcv *DAGPlan) MaxParallel() byte {
|
||||
o := flatbuffers.UOffsetT(rcv._tab.Offset(6))
|
||||
if o != 0 {
|
||||
return rcv._tab.GetByte(o + rcv._tab.Pos)
|
||||
}
|
||||
return 0
|
||||
}
|
||||
|
||||
func (rcv *DAGPlan) MutateMaxParallel(n byte) bool {
|
||||
return rcv._tab.MutateByteSlot(6, n)
|
||||
}
|
||||
|
||||
func (rcv *DAGPlan) TokenBudget() uint32 {
|
||||
o := flatbuffers.UOffsetT(rcv._tab.Offset(8))
|
||||
if o != 0 {
|
||||
return rcv._tab.GetUint32(o + rcv._tab.Pos)
|
||||
}
|
||||
return 0
|
||||
}
|
||||
|
||||
func (rcv *DAGPlan) MutateTokenBudget(n uint32) bool {
|
||||
return rcv._tab.MutateUint32Slot(8, n)
|
||||
}
|
||||
|
||||
func (rcv *DAGPlan) JoinerQuery() []byte {
|
||||
o := flatbuffers.UOffsetT(rcv._tab.Offset(10))
|
||||
if o != 0 {
|
||||
return rcv._tab.ByteVector(o + rcv._tab.Pos)
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func DAGPlanStart(builder *flatbuffers.Builder) {
|
||||
builder.StartObject(4)
|
||||
}
|
||||
func DAGPlanAddNodes(builder *flatbuffers.Builder, nodes flatbuffers.UOffsetT) {
|
||||
builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(nodes), 0)
|
||||
}
|
||||
func DAGPlanStartNodesVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT {
|
||||
return builder.StartVector(4, numElems, 4)
|
||||
}
|
||||
func DAGPlanAddMaxParallel(builder *flatbuffers.Builder, maxParallel byte) {
|
||||
builder.PrependByteSlot(1, maxParallel, 0)
|
||||
}
|
||||
func DAGPlanAddTokenBudget(builder *flatbuffers.Builder, tokenBudget uint32) {
|
||||
builder.PrependUint32Slot(2, tokenBudget, 0)
|
||||
}
|
||||
func DAGPlanAddJoinerQuery(builder *flatbuffers.Builder, joinerQuery flatbuffers.UOffsetT) {
|
||||
builder.PrependUOffsetTSlot(3, flatbuffers.UOffsetT(joinerQuery), 0)
|
||||
}
|
||||
func DAGPlanEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
|
||||
return builder.EndObject()
|
||||
}
|
||||
82
pkg/itr/itrfb/ExecWasm.go
Normal file
82
pkg/itr/itrfb/ExecWasm.go
Normal file
|
|
@ -0,0 +1,82 @@
|
|||
// Code generated by the FlatBuffers compiler. DO NOT EDIT.
|
||||
|
||||
package itrfb
|
||||
|
||||
import (
|
||||
flatbuffers "github.com/google/flatbuffers/go"
|
||||
)
|
||||
|
||||
type ExecWasm struct {
|
||||
_tab flatbuffers.Table
|
||||
}
|
||||
|
||||
func GetRootAsExecWasm(buf []byte, offset flatbuffers.UOffsetT) *ExecWasm {
|
||||
n := flatbuffers.GetUOffsetT(buf[offset:])
|
||||
x := &ExecWasm{}
|
||||
x.Init(buf, n+offset)
|
||||
return x
|
||||
}
|
||||
|
||||
func FinishExecWasmBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
|
||||
builder.Finish(offset)
|
||||
}
|
||||
|
||||
func GetSizePrefixedRootAsExecWasm(buf []byte, offset flatbuffers.UOffsetT) *ExecWasm {
|
||||
n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:])
|
||||
x := &ExecWasm{}
|
||||
x.Init(buf, n+offset+flatbuffers.SizeUint32)
|
||||
return x
|
||||
}
|
||||
|
||||
func FinishSizePrefixedExecWasmBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
|
||||
builder.FinishSizePrefixed(offset)
|
||||
}
|
||||
|
||||
func (rcv *ExecWasm) Init(buf []byte, i flatbuffers.UOffsetT) {
|
||||
rcv._tab.Bytes = buf
|
||||
rcv._tab.Pos = i
|
||||
}
|
||||
|
||||
func (rcv *ExecWasm) Table() flatbuffers.Table {
|
||||
return rcv._tab
|
||||
}
|
||||
|
||||
func (rcv *ExecWasm) ModuleKey() []byte {
|
||||
o := flatbuffers.UOffsetT(rcv._tab.Offset(4))
|
||||
if o != 0 {
|
||||
return rcv._tab.ByteVector(o + rcv._tab.Pos)
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func (rcv *ExecWasm) Entry() []byte {
|
||||
o := flatbuffers.UOffsetT(rcv._tab.Offset(6))
|
||||
if o != 0 {
|
||||
return rcv._tab.ByteVector(o + rcv._tab.Pos)
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func (rcv *ExecWasm) InputJson() []byte {
|
||||
o := flatbuffers.UOffsetT(rcv._tab.Offset(8))
|
||||
if o != 0 {
|
||||
return rcv._tab.ByteVector(o + rcv._tab.Pos)
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func ExecWasmStart(builder *flatbuffers.Builder) {
|
||||
builder.StartObject(3)
|
||||
}
|
||||
func ExecWasmAddModuleKey(builder *flatbuffers.Builder, moduleKey flatbuffers.UOffsetT) {
|
||||
builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(moduleKey), 0)
|
||||
}
|
||||
func ExecWasmAddEntry(builder *flatbuffers.Builder, entry flatbuffers.UOffsetT) {
|
||||
builder.PrependUOffsetTSlot(1, flatbuffers.UOffsetT(entry), 0)
|
||||
}
|
||||
func ExecWasmAddInputJson(builder *flatbuffers.Builder, inputJson flatbuffers.UOffsetT) {
|
||||
builder.PrependUOffsetTSlot(2, flatbuffers.UOffsetT(inputJson), 0)
|
||||
}
|
||||
func ExecWasmEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
|
||||
return builder.EndObject()
|
||||
}
|
||||
71
pkg/itr/itrfb/Final.go
Normal file
71
pkg/itr/itrfb/Final.go
Normal file
|
|
@ -0,0 +1,71 @@
|
|||
// Code generated by the FlatBuffers compiler. DO NOT EDIT.
|
||||
|
||||
package itrfb
|
||||
|
||||
import (
|
||||
flatbuffers "github.com/google/flatbuffers/go"
|
||||
)
|
||||
|
||||
type Final struct {
|
||||
_tab flatbuffers.Table
|
||||
}
|
||||
|
||||
func GetRootAsFinal(buf []byte, offset flatbuffers.UOffsetT) *Final {
|
||||
n := flatbuffers.GetUOffsetT(buf[offset:])
|
||||
x := &Final{}
|
||||
x.Init(buf, n+offset)
|
||||
return x
|
||||
}
|
||||
|
||||
func FinishFinalBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
|
||||
builder.Finish(offset)
|
||||
}
|
||||
|
||||
func GetSizePrefixedRootAsFinal(buf []byte, offset flatbuffers.UOffsetT) *Final {
|
||||
n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:])
|
||||
x := &Final{}
|
||||
x.Init(buf, n+offset+flatbuffers.SizeUint32)
|
||||
return x
|
||||
}
|
||||
|
||||
func FinishSizePrefixedFinalBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
|
||||
builder.FinishSizePrefixed(offset)
|
||||
}
|
||||
|
||||
func (rcv *Final) Init(buf []byte, i flatbuffers.UOffsetT) {
|
||||
rcv._tab.Bytes = buf
|
||||
rcv._tab.Pos = i
|
||||
}
|
||||
|
||||
func (rcv *Final) Table() flatbuffers.Table {
|
||||
return rcv._tab
|
||||
}
|
||||
|
||||
func (rcv *Final) Answer() []byte {
|
||||
o := flatbuffers.UOffsetT(rcv._tab.Offset(4))
|
||||
if o != 0 {
|
||||
return rcv._tab.ByteVector(o + rcv._tab.Pos)
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func (rcv *Final) VarName() []byte {
|
||||
o := flatbuffers.UOffsetT(rcv._tab.Offset(6))
|
||||
if o != 0 {
|
||||
return rcv._tab.ByteVector(o + rcv._tab.Pos)
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func FinalStart(builder *flatbuffers.Builder) {
|
||||
builder.StartObject(2)
|
||||
}
|
||||
func FinalAddAnswer(builder *flatbuffers.Builder, answer flatbuffers.UOffsetT) {
|
||||
builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(answer), 0)
|
||||
}
|
||||
func FinalAddVarName(builder *flatbuffers.Builder, varName flatbuffers.UOffsetT) {
|
||||
builder.PrependUOffsetTSlot(1, flatbuffers.UOffsetT(varName), 0)
|
||||
}
|
||||
func FinalEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
|
||||
return builder.EndObject()
|
||||
}
|
||||
90
pkg/itr/itrfb/Grep.go
Normal file
90
pkg/itr/itrfb/Grep.go
Normal file
|
|
@ -0,0 +1,90 @@
|
|||
// Code generated by the FlatBuffers compiler. DO NOT EDIT.
|
||||
|
||||
package itrfb
|
||||
|
||||
import (
|
||||
flatbuffers "github.com/google/flatbuffers/go"
|
||||
)
|
||||
|
||||
type Grep struct {
|
||||
_tab flatbuffers.Table
|
||||
}
|
||||
|
||||
func GetRootAsGrep(buf []byte, offset flatbuffers.UOffsetT) *Grep {
|
||||
n := flatbuffers.GetUOffsetT(buf[offset:])
|
||||
x := &Grep{}
|
||||
x.Init(buf, n+offset)
|
||||
return x
|
||||
}
|
||||
|
||||
func FinishGrepBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
|
||||
builder.Finish(offset)
|
||||
}
|
||||
|
||||
func GetSizePrefixedRootAsGrep(buf []byte, offset flatbuffers.UOffsetT) *Grep {
|
||||
n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:])
|
||||
x := &Grep{}
|
||||
x.Init(buf, n+offset+flatbuffers.SizeUint32)
|
||||
return x
|
||||
}
|
||||
|
||||
func FinishSizePrefixedGrepBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
|
||||
builder.FinishSizePrefixed(offset)
|
||||
}
|
||||
|
||||
func (rcv *Grep) Init(buf []byte, i flatbuffers.UOffsetT) {
|
||||
rcv._tab.Bytes = buf
|
||||
rcv._tab.Pos = i
|
||||
}
|
||||
|
||||
func (rcv *Grep) Table() flatbuffers.Table {
|
||||
return rcv._tab
|
||||
}
|
||||
|
||||
func (rcv *Grep) Pattern() []byte {
|
||||
o := flatbuffers.UOffsetT(rcv._tab.Offset(4))
|
||||
if o != 0 {
|
||||
return rcv._tab.ByteVector(o + rcv._tab.Pos)
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func (rcv *Grep) MaxMatches() uint32 {
|
||||
o := flatbuffers.UOffsetT(rcv._tab.Offset(6))
|
||||
if o != 0 {
|
||||
return rcv._tab.GetUint32(o + rcv._tab.Pos)
|
||||
}
|
||||
return 50
|
||||
}
|
||||
|
||||
func (rcv *Grep) MutateMaxMatches(n uint32) bool {
|
||||
return rcv._tab.MutateUint32Slot(6, n)
|
||||
}
|
||||
|
||||
func (rcv *Grep) CaseInsensitive() bool {
|
||||
o := flatbuffers.UOffsetT(rcv._tab.Offset(8))
|
||||
if o != 0 {
|
||||
return rcv._tab.GetBool(o + rcv._tab.Pos)
|
||||
}
|
||||
return false
|
||||
}
|
||||
|
||||
func (rcv *Grep) MutateCaseInsensitive(n bool) bool {
|
||||
return rcv._tab.MutateBoolSlot(8, n)
|
||||
}
|
||||
|
||||
func GrepStart(builder *flatbuffers.Builder) {
|
||||
builder.StartObject(3)
|
||||
}
|
||||
func GrepAddPattern(builder *flatbuffers.Builder, pattern flatbuffers.UOffsetT) {
|
||||
builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(pattern), 0)
|
||||
}
|
||||
func GrepAddMaxMatches(builder *flatbuffers.Builder, maxMatches uint32) {
|
||||
builder.PrependUint32Slot(1, maxMatches, 50)
|
||||
}
|
||||
func GrepAddCaseInsensitive(builder *flatbuffers.Builder, caseInsensitive bool) {
|
||||
builder.PrependBoolSlot(2, caseInsensitive, false)
|
||||
}
|
||||
func GrepEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
|
||||
return builder.EndObject()
|
||||
}
|
||||
105
pkg/itr/itrfb/Partition.go
Normal file
105
pkg/itr/itrfb/Partition.go
Normal file
|
|
@ -0,0 +1,105 @@
|
|||
// Code generated by the FlatBuffers compiler. DO NOT EDIT.
|
||||
|
||||
package itrfb
|
||||
|
||||
import (
|
||||
flatbuffers "github.com/google/flatbuffers/go"
|
||||
)
|
||||
|
||||
type Partition struct {
|
||||
_tab flatbuffers.Table
|
||||
}
|
||||
|
||||
func GetRootAsPartition(buf []byte, offset flatbuffers.UOffsetT) *Partition {
|
||||
n := flatbuffers.GetUOffsetT(buf[offset:])
|
||||
x := &Partition{}
|
||||
x.Init(buf, n+offset)
|
||||
return x
|
||||
}
|
||||
|
||||
func FinishPartitionBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
|
||||
builder.Finish(offset)
|
||||
}
|
||||
|
||||
func GetSizePrefixedRootAsPartition(buf []byte, offset flatbuffers.UOffsetT) *Partition {
|
||||
n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:])
|
||||
x := &Partition{}
|
||||
x.Init(buf, n+offset+flatbuffers.SizeUint32)
|
||||
return x
|
||||
}
|
||||
|
||||
func FinishSizePrefixedPartitionBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
|
||||
builder.FinishSizePrefixed(offset)
|
||||
}
|
||||
|
||||
func (rcv *Partition) Init(buf []byte, i flatbuffers.UOffsetT) {
|
||||
rcv._tab.Bytes = buf
|
||||
rcv._tab.Pos = i
|
||||
}
|
||||
|
||||
func (rcv *Partition) Table() flatbuffers.Table {
|
||||
return rcv._tab
|
||||
}
|
||||
|
||||
func (rcv *Partition) K() uint32 {
|
||||
o := flatbuffers.UOffsetT(rcv._tab.Offset(4))
|
||||
if o != 0 {
|
||||
return rcv._tab.GetUint32(o + rcv._tab.Pos)
|
||||
}
|
||||
return 4
|
||||
}
|
||||
|
||||
func (rcv *Partition) MutateK(n uint32) bool {
|
||||
return rcv._tab.MutateUint32Slot(4, n)
|
||||
}
|
||||
|
||||
func (rcv *Partition) Method() []byte {
|
||||
o := flatbuffers.UOffsetT(rcv._tab.Offset(6))
|
||||
if o != 0 {
|
||||
return rcv._tab.ByteVector(o + rcv._tab.Pos)
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func (rcv *Partition) Overlap() uint32 {
|
||||
o := flatbuffers.UOffsetT(rcv._tab.Offset(8))
|
||||
if o != 0 {
|
||||
return rcv._tab.GetUint32(o + rcv._tab.Pos)
|
||||
}
|
||||
return 0
|
||||
}
|
||||
|
||||
func (rcv *Partition) MutateOverlap(n uint32) bool {
|
||||
return rcv._tab.MutateUint32Slot(8, n)
|
||||
}
|
||||
|
||||
func (rcv *Partition) Semantic() bool {
|
||||
o := flatbuffers.UOffsetT(rcv._tab.Offset(10))
|
||||
if o != 0 {
|
||||
return rcv._tab.GetBool(o + rcv._tab.Pos)
|
||||
}
|
||||
return false
|
||||
}
|
||||
|
||||
func (rcv *Partition) MutateSemantic(n bool) bool {
|
||||
return rcv._tab.MutateBoolSlot(10, n)
|
||||
}
|
||||
|
||||
func PartitionStart(builder *flatbuffers.Builder) {
|
||||
builder.StartObject(4)
|
||||
}
|
||||
func PartitionAddK(builder *flatbuffers.Builder, k uint32) {
|
||||
builder.PrependUint32Slot(0, k, 4)
|
||||
}
|
||||
func PartitionAddMethod(builder *flatbuffers.Builder, method flatbuffers.UOffsetT) {
|
||||
builder.PrependUOffsetTSlot(1, flatbuffers.UOffsetT(method), 0)
|
||||
}
|
||||
func PartitionAddOverlap(builder *flatbuffers.Builder, overlap uint32) {
|
||||
builder.PrependUint32Slot(2, overlap, 0)
|
||||
}
|
||||
func PartitionAddSemantic(builder *flatbuffers.Builder, semantic bool) {
|
||||
builder.PrependBoolSlot(3, semantic, false)
|
||||
}
|
||||
func PartitionEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
|
||||
return builder.EndObject()
|
||||
}
|
||||
79
pkg/itr/itrfb/Peek.go
Normal file
79
pkg/itr/itrfb/Peek.go
Normal file
|
|
@ -0,0 +1,79 @@
|
|||
// Code generated by the FlatBuffers compiler. DO NOT EDIT.
|
||||
|
||||
package itrfb
|
||||
|
||||
import (
|
||||
flatbuffers "github.com/google/flatbuffers/go"
|
||||
)
|
||||
|
||||
type Peek struct {
|
||||
_tab flatbuffers.Table
|
||||
}
|
||||
|
||||
func GetRootAsPeek(buf []byte, offset flatbuffers.UOffsetT) *Peek {
|
||||
n := flatbuffers.GetUOffsetT(buf[offset:])
|
||||
x := &Peek{}
|
||||
x.Init(buf, n+offset)
|
||||
return x
|
||||
}
|
||||
|
||||
func FinishPeekBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
|
||||
builder.Finish(offset)
|
||||
}
|
||||
|
||||
func GetSizePrefixedRootAsPeek(buf []byte, offset flatbuffers.UOffsetT) *Peek {
|
||||
n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:])
|
||||
x := &Peek{}
|
||||
x.Init(buf, n+offset+flatbuffers.SizeUint32)
|
||||
return x
|
||||
}
|
||||
|
||||
func FinishSizePrefixedPeekBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
|
||||
builder.FinishSizePrefixed(offset)
|
||||
}
|
||||
|
||||
func (rcv *Peek) Init(buf []byte, i flatbuffers.UOffsetT) {
|
||||
rcv._tab.Bytes = buf
|
||||
rcv._tab.Pos = i
|
||||
}
|
||||
|
||||
func (rcv *Peek) Table() flatbuffers.Table {
|
||||
return rcv._tab
|
||||
}
|
||||
|
||||
func (rcv *Peek) Start() uint64 {
|
||||
o := flatbuffers.UOffsetT(rcv._tab.Offset(4))
|
||||
if o != 0 {
|
||||
return rcv._tab.GetUint64(o + rcv._tab.Pos)
|
||||
}
|
||||
return 0
|
||||
}
|
||||
|
||||
func (rcv *Peek) MutateStart(n uint64) bool {
|
||||
return rcv._tab.MutateUint64Slot(4, n)
|
||||
}
|
||||
|
||||
func (rcv *Peek) Length() uint32 {
|
||||
o := flatbuffers.UOffsetT(rcv._tab.Offset(6))
|
||||
if o != 0 {
|
||||
return rcv._tab.GetUint32(o + rcv._tab.Pos)
|
||||
}
|
||||
return 0
|
||||
}
|
||||
|
||||
func (rcv *Peek) MutateLength(n uint32) bool {
|
||||
return rcv._tab.MutateUint32Slot(6, n)
|
||||
}
|
||||
|
||||
func PeekStart(builder *flatbuffers.Builder) {
|
||||
builder.StartObject(2)
|
||||
}
|
||||
func PeekAddStart(builder *flatbuffers.Builder, start uint64) {
|
||||
builder.PrependUint64Slot(0, start, 0)
|
||||
}
|
||||
func PeekAddLength(builder *flatbuffers.Builder, length uint32) {
|
||||
builder.PrependUint32Slot(1, length, 0)
|
||||
}
|
||||
func PeekEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
|
||||
return builder.EndObject()
|
||||
}
|
||||
86
pkg/itr/itrfb/Recurse.go
Normal file
86
pkg/itr/itrfb/Recurse.go
Normal file
|
|
@ -0,0 +1,86 @@
|
|||
// Code generated by the FlatBuffers compiler. DO NOT EDIT.
|
||||
|
||||
package itrfb
|
||||
|
||||
import (
|
||||
flatbuffers "github.com/google/flatbuffers/go"
|
||||
)
|
||||
|
||||
type Recurse struct {
|
||||
_tab flatbuffers.Table
|
||||
}
|
||||
|
||||
func GetRootAsRecurse(buf []byte, offset flatbuffers.UOffsetT) *Recurse {
|
||||
n := flatbuffers.GetUOffsetT(buf[offset:])
|
||||
x := &Recurse{}
|
||||
x.Init(buf, n+offset)
|
||||
return x
|
||||
}
|
||||
|
||||
func FinishRecurseBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
|
||||
builder.Finish(offset)
|
||||
}
|
||||
|
||||
func GetSizePrefixedRootAsRecurse(buf []byte, offset flatbuffers.UOffsetT) *Recurse {
|
||||
n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:])
|
||||
x := &Recurse{}
|
||||
x.Init(buf, n+offset+flatbuffers.SizeUint32)
|
||||
return x
|
||||
}
|
||||
|
||||
func FinishSizePrefixedRecurseBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
|
||||
builder.FinishSizePrefixed(offset)
|
||||
}
|
||||
|
||||
func (rcv *Recurse) Init(buf []byte, i flatbuffers.UOffsetT) {
|
||||
rcv._tab.Bytes = buf
|
||||
rcv._tab.Pos = i
|
||||
}
|
||||
|
||||
func (rcv *Recurse) Table() flatbuffers.Table {
|
||||
return rcv._tab
|
||||
}
|
||||
|
||||
func (rcv *Recurse) SubQuery() []byte {
|
||||
o := flatbuffers.UOffsetT(rcv._tab.Offset(4))
|
||||
if o != 0 {
|
||||
return rcv._tab.ByteVector(o + rcv._tab.Pos)
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func (rcv *Recurse) ContextKey() []byte {
|
||||
o := flatbuffers.UOffsetT(rcv._tab.Offset(6))
|
||||
if o != 0 {
|
||||
return rcv._tab.ByteVector(o + rcv._tab.Pos)
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func (rcv *Recurse) DepthHint() byte {
|
||||
o := flatbuffers.UOffsetT(rcv._tab.Offset(8))
|
||||
if o != 0 {
|
||||
return rcv._tab.GetByte(o + rcv._tab.Pos)
|
||||
}
|
||||
return 3
|
||||
}
|
||||
|
||||
func (rcv *Recurse) MutateDepthHint(n byte) bool {
|
||||
return rcv._tab.MutateByteSlot(8, n)
|
||||
}
|
||||
|
||||
func RecurseStart(builder *flatbuffers.Builder) {
|
||||
builder.StartObject(3)
|
||||
}
|
||||
func RecurseAddSubQuery(builder *flatbuffers.Builder, subQuery flatbuffers.UOffsetT) {
|
||||
builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(subQuery), 0)
|
||||
}
|
||||
func RecurseAddContextKey(builder *flatbuffers.Builder, contextKey flatbuffers.UOffsetT) {
|
||||
builder.PrependUOffsetTSlot(1, flatbuffers.UOffsetT(contextKey), 0)
|
||||
}
|
||||
func RecurseAddDepthHint(builder *flatbuffers.Builder, depthHint byte) {
|
||||
builder.PrependByteSlot(2, depthHint, 3)
|
||||
}
|
||||
func RecurseEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
|
||||
return builder.EndObject()
|
||||
}
|
||||
71
pkg/itr/itrfb/ToolExec.go
Normal file
71
pkg/itr/itrfb/ToolExec.go
Normal file
|
|
@ -0,0 +1,71 @@
|
|||
// Code generated by the FlatBuffers compiler. DO NOT EDIT.
|
||||
|
||||
package itrfb
|
||||
|
||||
import (
|
||||
flatbuffers "github.com/google/flatbuffers/go"
|
||||
)
|
||||
|
||||
type ToolExec struct {
|
||||
_tab flatbuffers.Table
|
||||
}
|
||||
|
||||
func GetRootAsToolExec(buf []byte, offset flatbuffers.UOffsetT) *ToolExec {
|
||||
n := flatbuffers.GetUOffsetT(buf[offset:])
|
||||
x := &ToolExec{}
|
||||
x.Init(buf, n+offset)
|
||||
return x
|
||||
}
|
||||
|
||||
func FinishToolExecBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
|
||||
builder.Finish(offset)
|
||||
}
|
||||
|
||||
func GetSizePrefixedRootAsToolExec(buf []byte, offset flatbuffers.UOffsetT) *ToolExec {
|
||||
n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:])
|
||||
x := &ToolExec{}
|
||||
x.Init(buf, n+offset+flatbuffers.SizeUint32)
|
||||
return x
|
||||
}
|
||||
|
||||
func FinishSizePrefixedToolExecBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
|
||||
builder.FinishSizePrefixed(offset)
|
||||
}
|
||||
|
||||
func (rcv *ToolExec) Init(buf []byte, i flatbuffers.UOffsetT) {
|
||||
rcv._tab.Bytes = buf
|
||||
rcv._tab.Pos = i
|
||||
}
|
||||
|
||||
func (rcv *ToolExec) Table() flatbuffers.Table {
|
||||
return rcv._tab
|
||||
}
|
||||
|
||||
func (rcv *ToolExec) ToolName() []byte {
|
||||
o := flatbuffers.UOffsetT(rcv._tab.Offset(4))
|
||||
if o != 0 {
|
||||
return rcv._tab.ByteVector(o + rcv._tab.Pos)
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func (rcv *ToolExec) ArgsJson() []byte {
|
||||
o := flatbuffers.UOffsetT(rcv._tab.Offset(6))
|
||||
if o != 0 {
|
||||
return rcv._tab.ByteVector(o + rcv._tab.Pos)
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func ToolExecStart(builder *flatbuffers.Builder) {
|
||||
builder.StartObject(2)
|
||||
}
|
||||
func ToolExecAddToolName(builder *flatbuffers.Builder, toolName flatbuffers.UOffsetT) {
|
||||
builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(toolName), 0)
|
||||
}
|
||||
func ToolExecAddArgsJson(builder *flatbuffers.Builder, argsJson flatbuffers.UOffsetT) {
|
||||
builder.PrependUOffsetTSlot(1, flatbuffers.UOffsetT(argsJson), 0)
|
||||
}
|
||||
func ToolExecEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
|
||||
return builder.EndObject()
|
||||
}
|
||||
170
pkg/itr/itrfb/ToolRequest.go
Normal file
170
pkg/itr/itrfb/ToolRequest.go
Normal file
|
|
@ -0,0 +1,170 @@
|
|||
// Code generated by the FlatBuffers compiler. DO NOT EDIT.
|
||||
|
||||
package itrfb
|
||||
|
||||
import (
|
||||
flatbuffers "github.com/google/flatbuffers/go"
|
||||
)
|
||||
|
||||
type ToolRequest struct {
|
||||
_tab flatbuffers.Table
|
||||
}
|
||||
|
||||
func GetRootAsToolRequest(buf []byte, offset flatbuffers.UOffsetT) *ToolRequest {
|
||||
n := flatbuffers.GetUOffsetT(buf[offset:])
|
||||
x := &ToolRequest{}
|
||||
x.Init(buf, n+offset)
|
||||
return x
|
||||
}
|
||||
|
||||
func FinishToolRequestBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
|
||||
builder.Finish(offset)
|
||||
}
|
||||
|
||||
func GetSizePrefixedRootAsToolRequest(buf []byte, offset flatbuffers.UOffsetT) *ToolRequest {
|
||||
n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:])
|
||||
x := &ToolRequest{}
|
||||
x.Init(buf, n+offset+flatbuffers.SizeUint32)
|
||||
return x
|
||||
}
|
||||
|
||||
func FinishSizePrefixedToolRequestBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
|
||||
builder.FinishSizePrefixed(offset)
|
||||
}
|
||||
|
||||
func (rcv *ToolRequest) Init(buf []byte, i flatbuffers.UOffsetT) {
|
||||
rcv._tab.Bytes = buf
|
||||
rcv._tab.Pos = i
|
||||
}
|
||||
|
||||
func (rcv *ToolRequest) Table() flatbuffers.Table {
|
||||
return rcv._tab
|
||||
}
|
||||
|
||||
func (rcv *ToolRequest) Id() []byte {
|
||||
o := flatbuffers.UOffsetT(rcv._tab.Offset(4))
|
||||
if o != 0 {
|
||||
return rcv._tab.ByteVector(o + rcv._tab.Pos)
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func (rcv *ToolRequest) CmdType() CmdType {
|
||||
o := flatbuffers.UOffsetT(rcv._tab.Offset(6))
|
||||
if o != 0 {
|
||||
return CmdType(rcv._tab.GetInt8(o + rcv._tab.Pos))
|
||||
}
|
||||
return 0
|
||||
}
|
||||
|
||||
func (rcv *ToolRequest) MutateCmdType(n CmdType) bool {
|
||||
return rcv._tab.MutateInt8Slot(6, int8(n))
|
||||
}
|
||||
|
||||
func (rcv *ToolRequest) PayloadType() CommandPayload {
|
||||
o := flatbuffers.UOffsetT(rcv._tab.Offset(8))
|
||||
if o != 0 {
|
||||
return CommandPayload(rcv._tab.GetByte(o + rcv._tab.Pos))
|
||||
}
|
||||
return 0
|
||||
}
|
||||
|
||||
func (rcv *ToolRequest) MutatePayloadType(n CommandPayload) bool {
|
||||
return rcv._tab.MutateByteSlot(8, byte(n))
|
||||
}
|
||||
|
||||
func (rcv *ToolRequest) Payload(obj *flatbuffers.Table) bool {
|
||||
o := flatbuffers.UOffsetT(rcv._tab.Offset(10))
|
||||
if o != 0 {
|
||||
rcv._tab.Union(obj, o)
|
||||
return true
|
||||
}
|
||||
return false
|
||||
}
|
||||
|
||||
func (rcv *ToolRequest) DagPlan(obj *DAGPlan) *DAGPlan {
|
||||
o := flatbuffers.UOffsetT(rcv._tab.Offset(12))
|
||||
if o != 0 {
|
||||
x := rcv._tab.Indirect(o + rcv._tab.Pos)
|
||||
if obj == nil {
|
||||
obj = new(DAGPlan)
|
||||
}
|
||||
obj.Init(rcv._tab.Bytes, x)
|
||||
return obj
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func (rcv *ToolRequest) Timestamp() uint64 {
|
||||
o := flatbuffers.UOffsetT(rcv._tab.Offset(14))
|
||||
if o != 0 {
|
||||
return rcv._tab.GetUint64(o + rcv._tab.Pos)
|
||||
}
|
||||
return 0
|
||||
}
|
||||
|
||||
func (rcv *ToolRequest) MutateTimestamp(n uint64) bool {
|
||||
return rcv._tab.MutateUint64Slot(14, n)
|
||||
}
|
||||
|
||||
func (rcv *ToolRequest) Depth() byte {
|
||||
o := flatbuffers.UOffsetT(rcv._tab.Offset(16))
|
||||
if o != 0 {
|
||||
return rcv._tab.GetByte(o + rcv._tab.Pos)
|
||||
}
|
||||
return 0
|
||||
}
|
||||
|
||||
func (rcv *ToolRequest) MutateDepth(n byte) bool {
|
||||
return rcv._tab.MutateByteSlot(16, n)
|
||||
}
|
||||
|
||||
func (rcv *ToolRequest) SessionKey() []byte {
|
||||
o := flatbuffers.UOffsetT(rcv._tab.Offset(18))
|
||||
if o != 0 {
|
||||
return rcv._tab.ByteVector(o + rcv._tab.Pos)
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func (rcv *ToolRequest) ToolCallId() []byte {
|
||||
o := flatbuffers.UOffsetT(rcv._tab.Offset(20))
|
||||
if o != 0 {
|
||||
return rcv._tab.ByteVector(o + rcv._tab.Pos)
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func ToolRequestStart(builder *flatbuffers.Builder) {
|
||||
builder.StartObject(9)
|
||||
}
|
||||
func ToolRequestAddId(builder *flatbuffers.Builder, id flatbuffers.UOffsetT) {
|
||||
builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(id), 0)
|
||||
}
|
||||
func ToolRequestAddCmdType(builder *flatbuffers.Builder, cmdType CmdType) {
|
||||
builder.PrependInt8Slot(1, int8(cmdType), 0)
|
||||
}
|
||||
func ToolRequestAddPayloadType(builder *flatbuffers.Builder, payloadType CommandPayload) {
|
||||
builder.PrependByteSlot(2, byte(payloadType), 0)
|
||||
}
|
||||
func ToolRequestAddPayload(builder *flatbuffers.Builder, payload flatbuffers.UOffsetT) {
|
||||
builder.PrependUOffsetTSlot(3, flatbuffers.UOffsetT(payload), 0)
|
||||
}
|
||||
func ToolRequestAddDagPlan(builder *flatbuffers.Builder, dagPlan flatbuffers.UOffsetT) {
|
||||
builder.PrependUOffsetTSlot(4, flatbuffers.UOffsetT(dagPlan), 0)
|
||||
}
|
||||
func ToolRequestAddTimestamp(builder *flatbuffers.Builder, timestamp uint64) {
|
||||
builder.PrependUint64Slot(5, timestamp, 0)
|
||||
}
|
||||
func ToolRequestAddDepth(builder *flatbuffers.Builder, depth byte) {
|
||||
builder.PrependByteSlot(6, depth, 0)
|
||||
}
|
||||
func ToolRequestAddSessionKey(builder *flatbuffers.Builder, sessionKey flatbuffers.UOffsetT) {
|
||||
builder.PrependUOffsetTSlot(7, flatbuffers.UOffsetT(sessionKey), 0)
|
||||
}
|
||||
func ToolRequestAddToolCallId(builder *flatbuffers.Builder, toolCallId flatbuffers.UOffsetT) {
|
||||
builder.PrependUOffsetTSlot(8, flatbuffers.UOffsetT(toolCallId), 0)
|
||||
}
|
||||
func ToolRequestEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
|
||||
return builder.EndObject()
|
||||
}
|
||||
139
pkg/itr/itrfb/ToolResponse.go
Normal file
139
pkg/itr/itrfb/ToolResponse.go
Normal file
|
|
@ -0,0 +1,139 @@
|
|||
// Code generated by the FlatBuffers compiler. DO NOT EDIT.
|
||||
|
||||
package itrfb
|
||||
|
||||
import (
|
||||
flatbuffers "github.com/google/flatbuffers/go"
|
||||
)
|
||||
|
||||
type ToolResponse struct {
|
||||
_tab flatbuffers.Table
|
||||
}
|
||||
|
||||
func GetRootAsToolResponse(buf []byte, offset flatbuffers.UOffsetT) *ToolResponse {
|
||||
n := flatbuffers.GetUOffsetT(buf[offset:])
|
||||
x := &ToolResponse{}
|
||||
x.Init(buf, n+offset)
|
||||
return x
|
||||
}
|
||||
|
||||
func FinishToolResponseBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
|
||||
builder.Finish(offset)
|
||||
}
|
||||
|
||||
func GetSizePrefixedRootAsToolResponse(buf []byte, offset flatbuffers.UOffsetT) *ToolResponse {
|
||||
n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:])
|
||||
x := &ToolResponse{}
|
||||
x.Init(buf, n+offset+flatbuffers.SizeUint32)
|
||||
return x
|
||||
}
|
||||
|
||||
func FinishSizePrefixedToolResponseBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
|
||||
builder.FinishSizePrefixed(offset)
|
||||
}
|
||||
|
||||
func (rcv *ToolResponse) Init(buf []byte, i flatbuffers.UOffsetT) {
|
||||
rcv._tab.Bytes = buf
|
||||
rcv._tab.Pos = i
|
||||
}
|
||||
|
||||
func (rcv *ToolResponse) Table() flatbuffers.Table {
|
||||
return rcv._tab
|
||||
}
|
||||
|
||||
func (rcv *ToolResponse) Id() []byte {
|
||||
o := flatbuffers.UOffsetT(rcv._tab.Offset(4))
|
||||
if o != 0 {
|
||||
return rcv._tab.ByteVector(o + rcv._tab.Pos)
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func (rcv *ToolResponse) Result() []byte {
|
||||
o := flatbuffers.UOffsetT(rcv._tab.Offset(6))
|
||||
if o != 0 {
|
||||
return rcv._tab.ByteVector(o + rcv._tab.Pos)
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func (rcv *ToolResponse) IsError() bool {
|
||||
o := flatbuffers.UOffsetT(rcv._tab.Offset(8))
|
||||
if o != 0 {
|
||||
return rcv._tab.GetBool(o + rcv._tab.Pos)
|
||||
}
|
||||
return false
|
||||
}
|
||||
|
||||
func (rcv *ToolResponse) MutateIsError(n bool) bool {
|
||||
return rcv._tab.MutateBoolSlot(8, n)
|
||||
}
|
||||
|
||||
func (rcv *ToolResponse) LeakDetected() bool {
|
||||
o := flatbuffers.UOffsetT(rcv._tab.Offset(10))
|
||||
if o != 0 {
|
||||
return rcv._tab.GetBool(o + rcv._tab.Pos)
|
||||
}
|
||||
return false
|
||||
}
|
||||
|
||||
func (rcv *ToolResponse) MutateLeakDetected(n bool) bool {
|
||||
return rcv._tab.MutateBoolSlot(10, n)
|
||||
}
|
||||
|
||||
func (rcv *ToolResponse) CostTokens() uint32 {
|
||||
o := flatbuffers.UOffsetT(rcv._tab.Offset(12))
|
||||
if o != 0 {
|
||||
return rcv._tab.GetUint32(o + rcv._tab.Pos)
|
||||
}
|
||||
return 0
|
||||
}
|
||||
|
||||
func (rcv *ToolResponse) MutateCostTokens(n uint32) bool {
|
||||
return rcv._tab.MutateUint32Slot(12, n)
|
||||
}
|
||||
|
||||
func (rcv *ToolResponse) RedactedKeys(j int) []byte {
|
||||
o := flatbuffers.UOffsetT(rcv._tab.Offset(14))
|
||||
if o != 0 {
|
||||
a := rcv._tab.Vector(o)
|
||||
return rcv._tab.ByteVector(a + flatbuffers.UOffsetT(j*4))
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func (rcv *ToolResponse) RedactedKeysLength() int {
|
||||
o := flatbuffers.UOffsetT(rcv._tab.Offset(14))
|
||||
if o != 0 {
|
||||
return rcv._tab.VectorLen(o)
|
||||
}
|
||||
return 0
|
||||
}
|
||||
|
||||
func ToolResponseStart(builder *flatbuffers.Builder) {
|
||||
builder.StartObject(6)
|
||||
}
|
||||
func ToolResponseAddId(builder *flatbuffers.Builder, id flatbuffers.UOffsetT) {
|
||||
builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(id), 0)
|
||||
}
|
||||
func ToolResponseAddResult(builder *flatbuffers.Builder, result flatbuffers.UOffsetT) {
|
||||
builder.PrependUOffsetTSlot(1, flatbuffers.UOffsetT(result), 0)
|
||||
}
|
||||
func ToolResponseAddIsError(builder *flatbuffers.Builder, isError bool) {
|
||||
builder.PrependBoolSlot(2, isError, false)
|
||||
}
|
||||
func ToolResponseAddLeakDetected(builder *flatbuffers.Builder, leakDetected bool) {
|
||||
builder.PrependBoolSlot(3, leakDetected, false)
|
||||
}
|
||||
func ToolResponseAddCostTokens(builder *flatbuffers.Builder, costTokens uint32) {
|
||||
builder.PrependUint32Slot(4, costTokens, 0)
|
||||
}
|
||||
func ToolResponseAddRedactedKeys(builder *flatbuffers.Builder, redactedKeys flatbuffers.UOffsetT) {
|
||||
builder.PrependUOffsetTSlot(5, flatbuffers.UOffsetT(redactedKeys), 0)
|
||||
}
|
||||
func ToolResponseStartRedactedKeysVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT {
|
||||
return builder.StartVector(4, numElems, 4)
|
||||
}
|
||||
func ToolResponseEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
|
||||
return builder.EndObject()
|
||||
}
|
||||
75
pkg/itr/itrfb/ToolSearch.go
Normal file
75
pkg/itr/itrfb/ToolSearch.go
Normal file
|
|
@ -0,0 +1,75 @@
|
|||
// Code generated by the FlatBuffers compiler. DO NOT EDIT.
|
||||
|
||||
package itrfb
|
||||
|
||||
import (
|
||||
flatbuffers "github.com/google/flatbuffers/go"
|
||||
)
|
||||
|
||||
type ToolSearch struct {
|
||||
_tab flatbuffers.Table
|
||||
}
|
||||
|
||||
func GetRootAsToolSearch(buf []byte, offset flatbuffers.UOffsetT) *ToolSearch {
|
||||
n := flatbuffers.GetUOffsetT(buf[offset:])
|
||||
x := &ToolSearch{}
|
||||
x.Init(buf, n+offset)
|
||||
return x
|
||||
}
|
||||
|
||||
func FinishToolSearchBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
|
||||
builder.Finish(offset)
|
||||
}
|
||||
|
||||
func GetSizePrefixedRootAsToolSearch(buf []byte, offset flatbuffers.UOffsetT) *ToolSearch {
|
||||
n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:])
|
||||
x := &ToolSearch{}
|
||||
x.Init(buf, n+offset+flatbuffers.SizeUint32)
|
||||
return x
|
||||
}
|
||||
|
||||
func FinishSizePrefixedToolSearchBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) {
|
||||
builder.FinishSizePrefixed(offset)
|
||||
}
|
||||
|
||||
func (rcv *ToolSearch) Init(buf []byte, i flatbuffers.UOffsetT) {
|
||||
rcv._tab.Bytes = buf
|
||||
rcv._tab.Pos = i
|
||||
}
|
||||
|
||||
func (rcv *ToolSearch) Table() flatbuffers.Table {
|
||||
return rcv._tab
|
||||
}
|
||||
|
||||
func (rcv *ToolSearch) Query() []byte {
|
||||
o := flatbuffers.UOffsetT(rcv._tab.Offset(4))
|
||||
if o != 0 {
|
||||
return rcv._tab.ByteVector(o + rcv._tab.Pos)
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func (rcv *ToolSearch) MaxResults() byte {
|
||||
o := flatbuffers.UOffsetT(rcv._tab.Offset(6))
|
||||
if o != 0 {
|
||||
return rcv._tab.GetByte(o + rcv._tab.Pos)
|
||||
}
|
||||
return 10
|
||||
}
|
||||
|
||||
func (rcv *ToolSearch) MutateMaxResults(n byte) bool {
|
||||
return rcv._tab.MutateByteSlot(6, n)
|
||||
}
|
||||
|
||||
func ToolSearchStart(builder *flatbuffers.Builder) {
|
||||
builder.StartObject(2)
|
||||
}
|
||||
func ToolSearchAddQuery(builder *flatbuffers.Builder, query flatbuffers.UOffsetT) {
|
||||
builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(query), 0)
|
||||
}
|
||||
func ToolSearchAddMaxResults(builder *flatbuffers.Builder, maxResults byte) {
|
||||
builder.PrependByteSlot(1, maxResults, 10)
|
||||
}
|
||||
func ToolSearchEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
|
||||
return builder.EndObject()
|
||||
}
|
||||
Loading…
Add table
Reference in a new issue