go-fatedier-frp-delete-and-update

A painting is a person's account of this edit as text, recorded independently of the node mapping - a rendering often has several equally defensible answers where the mapping has one. Deletions and insertions carry no position on the opposite side in a painting, so that panel draws no caret for them.

Before1package rpc
2
3import (
4	"bufio"
5	"bytes"
6	"encoding/binary"
7	"errors"
8	"io"
9)
10
11func WriteBytes(w io.Writer, buf []byte) (int, error) {
12	out := bytes.NewBuffer(nil)
13	binary.Write(out, binary.BigEndian, int64(len(buf)))
14	out.Write(buf)
15	return w.Write(out.Bytes())
16}
17
18func ReadBytes(r io.Reader) ([]byte, error) {
19	// To compatible with UDP connection, use bufio reader here to avoid lost conent.
20	rd := bufio.NewReader(r)
21
22	var length int64
23	if err := binary.Read(rd, binary.BigEndian, &length); err != nil {
24		return nil, err
25	}
26	buffer := make([]byte, length)
27	n, err := io.ReadFull(rd, buffer)
28	if err != nil {
29		return nil, err
30	}
31	if int64(n) != length {
32		return nil, errors.New("invalid length")
33	}
34	return buffer, nil
35}
36

After1package rpc
2
3import (
4	"bytes"
5	"encoding/binary"
6	"errors"
7	"io"
8)
9
10func WriteBytes(w io.Writer, buf []byte) (int, error) {
11	out := bytes.NewBuffer(nil)
12	binary.Write(out, binary.BigEndian, int64(len(buf)))
13	out.Write(buf)
14	return w.Write(out.Bytes())
15}
16
17func ReadBytes(r io.Reader) ([]byte, error) {
18	var length int64
19	if err := binary.Read(r, binary.BigEndian, &length); err != nil {
20		return nil, err
21	}
22	buffer := make([]byte, length)
23	n, err := io.ReadFull(r, buffer)
24	if err != nil {
25		return nil, err
26	}
27	if int64(n) != length {
28		return nil, errors.New("invalid length")
29	}
30	return buffer, nil
31}
32

Before1package rpc
2
3import (
4	"bufio"
5	"bytes"
6	"encoding/binary"
7	"errors"
8	"io"
9)
10
11func WriteBytes(w io.Writer, buf []byte) (int, error) {
12	out := bytes.NewBuffer(nil)
13	binary.Write(out, binary.BigEndian, int64(len(buf)))
14	out.Write(buf)
15	return w.Write(out.Bytes())
16}
17
18func ReadBytes(r io.Reader) ([]byte, error) {
19	// To compatible with UDP connection, use bufio reader here to avoid lost conent.
20	rd := bufio.NewReader(r)
21
22	var length int64
23	if err := binary.Read(rd, binary.BigEndian, &length); err != nil {
24		return nil, err
25	}
26	buffer := make([]byte, length)
27	n, err := io.ReadFull(rd, buffer)
28	if err != nil {
29		return nil, err
30	}
31	if int64(n) != length {
32		return nil, errors.New("invalid length")
33	}
34	return buffer, nil
35}
36

After1package rpc
2
3import (
4	"bytes"
5	"encoding/binary"
6	"errors"
7	"io"
8)
9
10func WriteBytes(w io.Writer, buf []byte) (int, error) {
11	out := bytes.NewBuffer(nil)
12	binary.Write(out, binary.BigEndian, int64(len(buf)))
13	out.Write(buf)
14	return w.Write(out.Bytes())
15}
16
17func ReadBytes(r io.Reader) ([]byte, error) {
18	var length int64
19	if err := binary.Read(r, binary.BigEndian, &length); err != nil {
20		return nil, err
21	}
22	buffer := make([]byte, length)
23	n, err := io.ReadFull(r, buffer)
24	if err != nil {
25		return nil, err
26	}
27	if int64(n) != length {
28		return nil, errors.New("invalid length")
29	}
30	return buffer, nil
31}
32

Before1package rpc
2
3import (
4	"bufio"
5	"bytes"
6	"encoding/binary"
7	"errors"
8	"io"
9)
10
11func WriteBytes(w io.Writer, buf []byte) (int, error) {
12	out := bytes.NewBuffer(nil)
13	binary.Write(out, binary.BigEndian, int64(len(buf)))
14	out.Write(buf)
15	return w.Write(out.Bytes())
16}
17
18func ReadBytes(r io.Reader) ([]byte, error) {
19	// To compatible with UDP connection, use bufio reader here to avoid lost conent.
20	rd := bufio.NewReader(r)
21
22	var length int64
23	if err := binary.Read(rd, binary.BigEndian, &length); err != nil {
24		return nil, err
25	}
26	buffer := make([]byte, length)
27	n, err := io.ReadFull(rd, buffer)
28	if err != nil {
29		return nil, err
30	}
31	if int64(n) != length {
32		return nil, errors.New("invalid length")
33	}
34	return buffer, nil
35}
36

After1package rpc
2
3import (
4	"bytes"
5	"encoding/binary"
6	"errors"
7	"io"
8)
9
10func WriteBytes(w io.Writer, buf []byte) (int, error) {
11	out := bytes.NewBuffer(nil)
12	binary.Write(out, binary.BigEndian, int64(len(buf)))
13	out.Write(buf)
14	return w.Write(out.Bytes())
15}
16
17func ReadBytes(r io.Reader) ([]byte, error) {
18	var length int64
19	if err := binary.Read(r, binary.BigEndian, &length); err != nil {
20		return nil, err
21	}
22	buffer := make([]byte, length)
23	n, err := io.ReadFull(r, buffer)
24	if err != nil {
25		return nil, err
26	}
27	if int64(n) != length {
28		return nil, errors.New("invalid length")
29	}
30	return buffer, nil
31}
32

Before

source_file

package_clause

package "package"

package_identifier "rpc"

import_declaration

import "import"

import_spec_list

( "("

import_spec

interpreted_string_literal

" "\""

interpreted_string_literal_content "bufio"

" "\""

import_spec

interpreted_string_literal

" "\""

interpreted_string_literal_content "bytes"

" "\""

import_spec

interpreted_string_literal

" "\""

interpreted_string_literal_content "encoding/binary"

" "\""

import_spec

interpreted_string_literal

" "\""

interpreted_string_literal_content "errors"

" "\""

import_spec

interpreted_string_literal

" "\""

interpreted_string_literal_content "io"

" "\""

) ")"

function_declaration (+101 nodes collapsed)

function_declaration

func "func"

identifier "ReadBytes"

parameter_list

( "("

parameter_declaration

identifier "r"

qualified_type

package_identifier "io"

. "."

type_identifier "Reader"

) ")"

parameter_list

( "("

parameter_declaration

slice_type

[ "["

] "]"

type_identifier "byte"

, ","

parameter_declaration

type_identifier "error"

) ")"

block

{ "{"

comment "// To compatible with UDP connection, use bufio reader here "...

statement_list

short_var_declaration

expression_list

identifier "rd"

:= ":="

expression_list

call_expression

selector_expression

identifier "bufio"

. "."

field_identifier "NewReader"

argument_list

( "("

identifier "r"

) ")"

var_declaration

var "var"

var_spec

identifier "length"

type_identifier "int64"

if_statement

if "if"

short_var_declaration

expression_list

identifier "err"

:= ":="

expression_list

call_expression

selector_expression

identifier "binary"

. "."

field_identifier "Read"

argument_list

( "("

identifier "rd"

, ","

selector_expression

identifier "binary"

. "."

field_identifier "BigEndian"

, ","

unary_expression

& "&"

identifier "length"

) ")"

; ";"

binary_expression

identifier "err"

!= "!="

nil "nil"

block

{ "{"

statement_list

return_statement

return "return"

expression_list

nil "nil"

, ","

identifier "err"

} "}"

short_var_declaration

expression_list

identifier "buffer"

:= ":="

expression_list

call_expression

identifier "make"

argument_list

( "("

slice_type

[ "["

] "]"

type_identifier "byte"

, ","

identifier "length"

) ")"

short_var_declaration

expression_list

identifier "n"

, ","

identifier "err"

:= ":="

expression_list

call_expression

selector_expression

identifier "io"

. "."

field_identifier "ReadFull"

argument_list

( "("

identifier "rd"

, ","

identifier "buffer"

) ")"

if_statement

if "if"

binary_expression

identifier "err"

!= "!="

nil "nil"

block

{ "{"

statement_list

return_statement

return "return"

expression_list

nil "nil"

, ","

identifier "err"

} "}"

if_statement (+32 nodes collapsed)

return_statement

return "return"

expression_list

identifier "buffer"

, ","

nil "nil"

} "}"

After

source_file

package_clause

package "package"

package_identifier "rpc"

import_declaration

import "import"

import_spec_list

( "("

import_spec

interpreted_string_literal

" "\""

interpreted_string_literal_content "bytes"

" "\""

import_spec

interpreted_string_literal

" "\""

interpreted_string_literal_content "encoding/binary"

" "\""

import_spec

interpreted_string_literal

" "\""

interpreted_string_literal_content "errors"

" "\""

import_spec

interpreted_string_literal

" "\""

interpreted_string_literal_content "io"

" "\""

) ")"

function_declaration (+101 nodes collapsed)

function_declaration

func "func"

identifier "ReadBytes"

parameter_list

( "("

parameter_declaration

identifier "r"

qualified_type

package_identifier "io"

. "."

type_identifier "Reader"

) ")"

parameter_list

( "("

parameter_declaration

slice_type

[ "["

] "]"

type_identifier "byte"

, ","

parameter_declaration

type_identifier "error"

) ")"

block

{ "{"

statement_list

var_declaration

var "var"

var_spec

identifier "length"

type_identifier "int64"

if_statement

if "if"

short_var_declaration

expression_list

identifier "err"

:= ":="

expression_list

call_expression

selector_expression

identifier "binary"

. "."

field_identifier "Read"

argument_list

( "("

identifier "r"

, ","

selector_expression

identifier "binary"

. "."

field_identifier "BigEndian"

, ","

unary_expression

& "&"

identifier "length"

) ")"

; ";"

binary_expression

identifier "err"

!= "!="

nil "nil"

block

{ "{"

statement_list

return_statement

return "return"

expression_list

nil "nil"

, ","

identifier "err"

} "}"

short_var_declaration

expression_list

identifier "buffer"

:= ":="

expression_list

call_expression

identifier "make"

argument_list

( "("

slice_type

[ "["

] "]"

type_identifier "byte"

, ","

identifier "length"

) ")"

short_var_declaration

expression_list

identifier "n"

, ","

identifier "err"

:= ":="

expression_list

call_expression

selector_expression

identifier "io"

. "."

field_identifier "ReadFull"

argument_list

( "("

identifier "r"

, ","

identifier "buffer"

) ")"

if_statement

if "if"

binary_expression

identifier "err"

!= "!="

nil "nil"

block

{ "{"

statement_list

return_statement

return "return"

expression_list

nil "nil"

, ","

identifier "err"

} "}"

if_statement (+32 nodes collapsed)

return_statement

return "return"

expression_list

identifier "buffer"

, ","

nil "nil"

} "}"