archived-old-code.tar

old-v2/string.go000644 001750 001750 00000003202 14665232133 014264 0ustar00dev1729dev1729000000 000000 // Copyright (C) 2024 Abhijit Bose (aka. Boseji). All rights reserved.
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//    http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
// SPDX short identifier: Apache-2.0

package tppi

import (
	"bytes"
	"fmt"

	"guthub.com/boseji/go-tppi/values"
)

func ToString(arg any, format string, buf *bytes.Buffer) (err error) {
	bt, _ := values.Describe(arg)
	if bt == values.BaseInvalid {
		err = fmt.Errorf("unsupported type for string conversion")
		return
	}
	// Prepare the String
	s := fmt.Sprintf(format, arg)
	n, err := buf.WriteString(s)
	if err != nil {
		err = fmt.Errorf("failed to convert to string due to - %v", err)
		return
	}
	if n != len(s) {
		err = fmt.Errorf("insufficient data written for string conversion")
	}
	return
}

func FromString(arg any, buf *bytes.Buffer, format string) (err error) {
	bt, _ := values.Describe(arg)
	if bt == values.BaseInvalid {
		err = fmt.Errorf("unsupported type for string recovery")
		return
	}
	n, err := fmt.Fscanf(buf, format, arg)
	if err != nil {
		err = fmt.Errorf("failed to recover string from buffer as - %v", err)
		return
	}
	if n != 1 {
		err = fmt.Errorf("could not recover the string properly")
	}
	return
}
old-v1/tppi.go000644 001750 001750 00000005054 14665231776 013754 0ustar00dev1729dev1729000000 000000 // Copyright (C) 2024 Abhijit Bose (aka. Boseji). All rights reserved.
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//    http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
// SPDX short identifier: Apache-2.0

// Tilde Pipe simPle Interface

package tppi

import "fmt"

// InLiner is a type that helps to prepare data as per the TPPI protocol needs
type InLiner interface {
	// Add collection of strings to a line
	Add(...string) error
	// Gets the Contents from the InLiner
	Contents() []string
	// Get the output with proper formatting for the line
	Processed() (string, error)
	// Restore contents from a processes line as input
	Decode(string) error
	// Clear the contents of the InLiner
	Clear()
}

// Formatter is the Encoding format for the TPPI
type Formatter interface {
	// Provides a unique signature that indicates which formatter to use
	Mark() string
	// Provides a way to translate any datatype into the specified format
	Encode(any) (string, error)
	// Provides a way to translate the string back to specified datatype
	Decode(any, string) (any, error)
}

// Spec provides a way to specify the data representation form for
// TPPI protocol. This encloses an unique signature, formatter and
// the value of the given data.
type Spec interface {
	// A unique signature of the data representation
	Sig() []string
	// Set a Encoding format for the Data present in the spec
	Format(Formatter) error
	// Provides a Value Representation of the data to be processed
	Get() ([]string, error)
	// Helps to recover the data embedded, the first parameter being
	// the Signature and the second being the value.
	Restore([]string, []string) error
}

// RunLiner helps to automate the Steps involved in creation of the single
// InLine from the collection on inputs.
func RunLiner(l InLiner, sa ...string) (s string, err error) {
	// Clear the Liner
	l.Clear()
	// Add array
	err = l.Add(sa...)
	if err != nil {
		err = fmt.Errorf("failed to add strings to the inliner - %v", err)
		return
	}
	// Get String
	s, err = l.Processed()
	if err != nil {
		err = fmt.Errorf("failed to process the strings from inliner - %v", err)
		return
	}
	return
}
old-v1/string_format_test.go000644 001750 001750 00000007473 14665231727 016720 0ustar00dev1729dev1729000000 000000 // Copyright (C) 2024 Abhijit Bose (aka. Boseji). All rights reserved.
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//    http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
// SPDX short identifier: Apache-2.0

package tppi

import (
	"reflect"
	"testing"
)

func TestStringFormat_Encode(t *testing.T) {
	type args struct {
		arg any
	}
	tests := []struct {
		name    string
		options []StringFormatOptions
		args    args
		wantS   string
		wantErr bool
	}{
		{
			name: "Encode String with quotes",
			options: []StringFormatOptions{
				WithStringFormat("%q"),
			},
			args: args{
				arg: "Hari Aum",
			},
			wantS: "\"Hari Aum\"",
		},
		{
			name:    "Encode normal Number",
			options: []StringFormatOptions{},
			args: args{
				arg: 0x3508,
			},
			wantS: "13576",
		},
		{
			name:    "Encode normal Boolean",
			options: []StringFormatOptions{},
			args: args{
				arg: true,
			},
			wantS: "true",
		},
		{
			name: "Encode Number in Hex",
			options: []StringFormatOptions{
				WithStringFormat("%X"),
			},
			args: args{
				arg: 0x3508,
			},
			wantS: "3508",
		},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			sf := NewStringFormat(tt.options...)
			gotS, err := sf.Encode(tt.args.arg)
			if (err != nil) != tt.wantErr {
				t.Errorf("StringFormat.Encode() error = %v, wantErr %v", err, tt.wantErr)
				return
			}
			if gotS != tt.wantS {
				t.Errorf("StringFormat.Encode() = %v, want %v", gotS, tt.wantS)
			}
		})
	}
}

func TestStringFormat_Decode(t *testing.T) {
	type args struct {
		arg any
		s   string
	}
	tests := []struct {
		name    string
		options []StringFormatOptions
		args    args
		wantVal any
		wantErr bool
	}{
		{
			name: "Positive Decode Quoted String",
			options: []StringFormatOptions{
				WithStringFormat("%q"),
			},
			args: args{
				arg: new(string),
				s:   "\"Hari Aum\"",
			},
			wantVal: func() *string {
				s := "Hari Aum"
				return &s
			}(),
		},
		{
			name:    "Positive Decode normal Number",
			options: []StringFormatOptions{},
			args: args{
				s:   "13576",
				arg: new(uint32),
			},
			wantVal: func() *uint32 {
				v := uint32(0x3508)
				return &v
			}(),
		},
		{
			name:    "Positive Decode normal bool",
			options: []StringFormatOptions{},
			args: args{
				s:   "true",
				arg: new(bool),
			},
			wantVal: func() *bool {
				v := true
				return &v
			}(),
		},
		{
			name: "Positive Decode Number in Hex Format",
			options: []StringFormatOptions{
				WithStringFormat("%X"),
			},
			args: args{
				s:   "3508",
				arg: new(uint32),
			},
			wantVal: func() *uint32 {
				v := uint32(0x3508)
				return &v
			}(),
		},
		{
			name:    "Negative Error in type",
			options: []StringFormatOptions{},
			args: args{
				s:   "Help",
				arg: new(uint32),
			},
			wantErr: true,
		},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			sf := NewStringFormat(tt.options...)
			gotVal, err := sf.Decode(tt.args.arg, tt.args.s)
			if (err != nil) != tt.wantErr {
				t.Errorf("StringFormat.Decode() error = %v, wantErr %v", err, tt.wantErr)
				return
			}
			if !reflect.DeepEqual(gotVal, tt.wantVal) && !tt.wantErr {
				t.Errorf("HexFormat.decode() = %v, want %v", gotVal, tt.wantVal)
			}
		})
	}
}

func TestStringFormat_other(t *testing.T) {
	sf := NewStringFormat()
	if s, ok := sf.(*StringFormat); ok && s.Mark() != stringFormatMark {
		t.Errorf("Error in NewStringFormat default format")
		return
	}
}
old-v2/binary_endian_big.go000644 001750 001750 00000001671 14665232075 016416 0ustar00dev1729dev1729000000 000000 // Copyright (C) 2024 Abhijit Bose (aka. Boseji). All rights reserved.
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//    http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
// SPDX short identifier: Apache-2.0

//go:build armbe || arm64be || m68k || mips || mips64 || mips64p32 || ppc || ppc64 || s390 || s390x || shbe || sparc || sparc64

package tppi

// IsLittleEndian helps to determine if the Machine architecture is
// Little Endian or Big Endian
func IsLittleEndian() bool {
	return false
}
old-v1/binary.go000644 001750 001750 00000003040 14665231652 014246 0ustar00dev1729dev1729000000 000000 // Copyright (C) 2024 Abhijit Bose (aka. Boseji). All rights reserved.
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//    http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
// SPDX short identifier: Apache-2.0

package tppi

import (
	"bytes"
	"encoding/binary"
	"fmt"
)

// ToBinary function provides a way to convert a given datatype into its Binary
// representation.
func ToBinary(arg any, littleEndian bool, buf *bytes.Buffer) (err error) {
	// For all other data type
	if littleEndian {
		err = binary.Write(buf, binary.LittleEndian, arg)
	} else {
		err = binary.Write(buf, binary.BigEndian, arg)
	}
	if err != nil {
		err = fmt.Errorf("failed to convert to binary : %v", err)
	}
	return
}

// FromBinary function provides a way to Binary data back into the the
// respective Datatype representation.
func FromBinary(arg any, buf *bytes.Buffer, littleEndian bool) (err error) {
	if littleEndian {
		err = binary.Read(buf, binary.LittleEndian, arg)
	} else {
		err = binary.Read(buf, binary.BigEndian, arg)
	}
	if err != nil {
		err = fmt.Errorf("failed to convert back from binary : %v", err)
	}
	return
}
old-v2/tppi_new_test.go000644 001750 001750 00000004463 14665232163 015657 0ustar00dev1729dev1729000000 000000 // Copyright (C) 2024 Abhijit Bose (aka. Boseji). All rights reserved.
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//    http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
// SPDX short identifier: Apache-2.0

// Tilde Pipe simPle Interface

package tppi

import (
	"encoding/binary"
	"fmt"
	"reflect"
	"testing"
)

func codeUint(u any) (s string, err error) {
	// Get Value Handle
	val := reflect.ValueOf(u)
	// Get the Kind
	k := val.Kind()
	// Used to Pull Values from
	v := val
	if k == reflect.Pointer {
		k = val.Elem().Kind()
		v = val.Elem()
	}
	switch k {
	case reflect.Bool:
		fmt.Println(v.Type().String(), val.Kind(), v.Bool())
	case reflect.Slice:
		fmt.Println(v.Cap(), v.Len(), v.Type().Elem().Kind())
	case reflect.Int:
		fmt.Println(binary.Size(val.Int()), val.Int())
	case reflect.Uint32:
		fmt.Println(binary.Size(val.Uint()), val.Uint())
	default:
		err = fmt.Errorf("wrong type: %s", k.String())
		return
	}
	return
}
func Test_ReflectBasic(t *testing.T) {
	type possible bool
	v := true
	xs := []byte{1, 2, 3}
	st := struct {
		Name string
		Id   uint16
	}{
		Name: "Mohan",
		Id:   33,
	}
	pv := possible(true)
	fmt.Println("Bool", v)
	fmt.Println("Byte Slice", xs)
	fmt.Printf("Struct %#v\n", st)
	fmt.Print("Bool Value = ")
	fmt.Println(codeUint(v))
	fmt.Print("Bool Pointer = ")
	fmt.Println(codeUint(&v))
	fmt.Print("ByteSlice = ")
	fmt.Println(codeUint(xs))
	fmt.Print("ByteSlice Pointer = ")
	fmt.Println(codeUint(&xs))
	fmt.Print("Struct = ")
	fmt.Println(codeUint(st))
	fmt.Print("Struct Pointer = ")
	fmt.Println(codeUint(&st))
	fmt.Print("Special Value enclosed Boolean = ")
	fmt.Println(codeUint(pv))
	fmt.Print("Special Pointer enclosed Boolean = ")
	fmt.Println(codeUint(&pv))
	fmt.Print("Blank Byte Slice = ")
	fmt.Println(codeUint(make([]byte, 0)))
	fmt.Print("int = ")
	fmt.Println(codeUint(int(5)))
	fmt.Print("uint32 = ")
	fmt.Println(codeUint(uint32(5)))
}
old-v1/rules_test.go000644 001750 001750 00000006141 14665231711 015154 0ustar00dev1729dev1729000000 000000 // Copyright (C) 2024 Abhijit Bose (aka. Boseji). All rights reserved.
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//    http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
// SPDX short identifier: Apache-2.0

package tppi

import (
	"fmt"
	"reflect"
	"strings"
	"testing"
)

// failingRule function Simulates Failing rule
func failingRule(s string) (sv string, err error) {
	err = fmt.Errorf("this is a failing rule")
	return
}

// workingRule function Simulates a Working rule
func workingRule(s string) (sv string, err error) {
	if strings.Contains(s, "+") {
		sv = s + "@"
	} else {
		sv = s
	}
	return
}

func TestRunRules(t *testing.T) {
	type args struct {
		ra map[string]Rules
		sa []string
	}
	tests := []struct {
		name    string
		args    args
		wantSv  []string
		wantErr bool
	}{
		{
			name: "Negative Empty Strings",
			args: args{
				ra: map[string]Rules{
					"Working": workingRule,
				},
				sa: nil,
			},
			wantErr: true,
		},
		{
			name: "Negative Empty Rules Set",
			args: args{
				ra: nil,
				sa: []string{
					"Hare Krishna",
				},
			},
			wantErr: true,
		},
		{
			name: "Positive with no change only 1 string",
			args: args{
				ra: map[string]Rules{
					"Working": workingRule,
				},
				sa: []string{
					"Hare Krishna",
				},
			},
			wantSv: []string{
				"Hare Krishna",
			},
		},
		{
			name: "Positive with change only 1 string",
			args: args{
				ra: map[string]Rules{
					"Working": workingRule,
				},
				sa: []string{
					"Hare Krishna+",
				},
			},
			wantSv: []string{
				"Hare Krishna+@",
			},
		},
		{
			name: "Positive with no change multiple string",
			args: args{
				ra: map[string]Rules{
					"Working": workingRule,
				},
				sa: []string{
					"Hare Krishna",
					"Hare Ram",
				},
			},
			wantSv: []string{
				"Hare Krishna",
				"Hare Ram",
			},
		},
		{
			name: "Positive with multiple change multiple string",
			args: args{
				ra: map[string]Rules{
					"Working": workingRule,
				},
				sa: []string{
					"Hare +Krishna",
					"+Hare +Ram",
				},
			},
			wantSv: []string{
				"Hare +Krishna@",
				"+Hare +Ram@",
			},
		},

		{
			name: "Negative with failing rules",
			args: args{
				ra: map[string]Rules{
					"Mock Rule": failingRule,
				},
				sa: []string{
					"Hare +Krishna",
					"+Hare +Ram",
				},
			},
			wantErr: true,
		},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			gotSv, err := RunRules(tt.args.ra, tt.args.sa...)
			if (err != nil) != tt.wantErr {
				t.Errorf("RunRules() error = %v, wantErr %v", err, tt.wantErr)
				return
			}
			if !reflect.DeepEqual(gotSv, tt.wantSv) && !tt.wantErr {
				t.Errorf("RunRules() = %v, want %v", gotSv, tt.wantSv)
			}
		})
	}
}
data/values_int_test.go000644 001750 001750 00000005513 14665101126 016000 0ustar00dev1729dev1729000000 000000 // Copyright (C) 2024 Abhijit Bose (aka. Boseji). All rights reserved.
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//    http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
// SPDX short identifier: Apache-2.0

package data

import (
	"reflect"
	"strings"
	"testing"
)

func Test_Int(t *testing.T) {
	tests := []struct {
		name  string
		value Int
		wantS string
		wantT string
	}{
		{
			name:  "Int representation1",
			value: NewInt(5),
			wantS: "5",
			wantT: intTypeSignature,
		},
		{
			name:  "Int representation2",
			value: NewInt(0x3508A),
			wantS: "3508a",
			wantT: intTypeSignature,
		},
		{
			name:  "Int representation3",
			value: NewInt(-1729),
			wantS: "-6c1",
			wantT: intTypeSignature,
		},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			gotS := tt.value.String()
			gotT := tt.value.Type()
			if strings.Compare(gotS, tt.wantS) != 0 {
				t.Errorf("error in String got %v expected %v", gotS, tt.wantS)
				return
			}
			if strings.Compare(gotT, tt.wantT) != 0 {
				t.Errorf("error in Type got %v expected %v", gotT, tt.wantT)
			}
		})
	}
	tests2 := []struct {
		name    string
		argType string
		argTag  string
		argData string
		want    Int
		wantErr bool
	}{
		{
			name:    "Int recovery1",
			argType: intTypeSignature,
			argTag:  "",
			argData: "5",
			want:    NewInt(5),
		},
		{
			name:    "Int recovery2",
			argType: intTypeSignature,
			argTag:  "temp",
			argData: "3508a",
			want:    NewInt(0x3508A).SetTag("temp"),
		},
		{
			name:    "Int recovery3",
			argType: intTypeSignature,
			argTag:  "level",
			argData: "-6c1",
			want:    NewInt(-1729).SetTag("level"),
		},
		{
			name:    "Int recovery Error1",
			argType: "k",
			argTag:  "",
			argData: "3508a",
			wantErr: true,
		},
		{
			name:    "Int recovery Error2",
			argType: intTypeSignature,
			argTag:  "",
			argData: "=2p1",
			wantErr: true,
		},
		{
			name:    "Int recovery Error3",
			argType: intTypeSignature,
			argTag:  "",
			argData: "ffffffffffffffff",
			wantErr: true,
		},
	}
	for _, tt := range tests2 {
		t.Run(tt.name, func(t *testing.T) {
			i := NewInt(0)
			err := i.Recover(tt.argType, tt.argTag, tt.argData)
			if (err != nil) != tt.wantErr {
				t.Errorf("failed to Recover() error - %v want error %v",
					err, tt.wantErr)
				return
			}
			if !tt.wantErr && !reflect.DeepEqual(i, tt.want) {
				t.Errorf("value error got %#v expected %#v", i, tt.want)
			}
		})
	}
}
old-v1/rules.go000644 001750 001750 00000003321 14665231721 014113 0ustar00dev1729dev1729000000 000000 // Copyright (C) 2024 Abhijit Bose (aka. Boseji). All rights reserved.
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//    http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
// SPDX short identifier: Apache-2.0

package tppi

import "fmt"

// Rules are specific operations followed for representation of a Line in
// the TPPI Protocol
type Rules func(string) (string, error)

// CollectionRule applies on a collection of Strings to prepare a specific
// Representation
type CollectionRule func(...string) (string, error)

// Splitting Rule breaks the input into a Collection of strings from
// and input containing a specific format
type SplittingRule func(string) ([]string, error)

// RunRules helps to run a collection of rules on a collection of input
// strings.
func RunRules(ra map[string]Rules, sa ...string) (sv []string, err error) {
	if len(sa) == 0 {
		err = fmt.Errorf("no inputs supplied to run rules")
		return
	}
	if len(ra) == 0 {
		err = fmt.Errorf("no rules specified to run")
		return
	}

	// Build
	sv = make([]string, 0, len(sa))
	for _, si := range sa {
		for name, r := range ra {
			var tmp string
			tmp, err = r(si)
			if err != nil {
				err = fmt.Errorf("error running %q rule - %v", name, err)
				return
			}
			si = tmp
		}
		sv = append(sv, si)
	}
	return
}
old-v2/binary_test.go000644 001750 001750 00000016526 14665232115 015316 0ustar00dev1729dev1729000000 000000 // Copyright (C) 2024 Abhijit Bose (aka. Boseji). All rights reserved.
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//    http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
// SPDX short identifier: Apache-2.0

package tppi

import (
	"bytes"
	"fmt"
	"reflect"
	"testing"
)

func TestToBinary(t *testing.T) {
	type args struct {
		arg          any
		littleEndian bool
	}
	tests := []struct {
		name    string
		args    args
		wantBuf *bytes.Buffer
		wantErr bool
	}{
		{
			name: "Normal conversion of a uint32 variable",
			args: args{
				arg:          uint32(0x3508),
				littleEndian: true,
			},
			wantBuf: bytes.NewBuffer([]byte{
				0x08, 0x35, 0x00, 0x00,
			}),
		},
		{
			name: "Normal conversion of a float64 variable",
			args: args{
				arg:          float64(10.34e15),
				littleEndian: true,
			},
			wantBuf: bytes.NewBuffer([]byte{
				0, 32, 125, 109, 22, 94, 66, 67,
			}),
		},
		{
			name: "Negative for string variable",
			args: args{
				arg:          "Testing String",
				littleEndian: true,
			},
			wantBuf: bytes.NewBuffer([]byte{}),
			wantErr: true,
		},
		{
			name: "Negative Struct",
			args: args{
				arg: struct {
					s string
				}{},
				littleEndian: true,
			},
			wantBuf: bytes.NewBuffer([]byte{}),
			wantErr: true,
		},
		{
			name: "Negative Map",
			args: args{
				arg:          map[int][]byte{},
				littleEndian: true,
			},
			wantBuf: bytes.NewBuffer([]byte{}),
			wantErr: true,
		},
		{
			name: "Normal conversion of a uint32 variable in bigEndian",
			args: args{
				arg:          uint32(0x3508),
				littleEndian: false,
			},
			wantBuf: bytes.NewBuffer([]byte{
				0x00, 0x00, 0x35, 0x08,
			}),
		},
		{
			name: "Normal conversion of a []byte variable",
			args: args{
				arg:          []byte{0x35, 0x08},
				littleEndian: true,
			},
			wantBuf: bytes.NewBuffer([]byte{0x35, 0x08}),
		},
		{
			name: "Normal conversion of a []uint32 variable",
			args: args{
				arg:          []uint32{0x35, 0x08},
				littleEndian: true,
			},
			wantBuf: bytes.NewBuffer([]byte{
				0x35, 0x00, 0x00, 0x00,
				0x08, 0x00, 0x00, 0x00,
			}),
		},
		{
			name: "Normal conversion of a []uint16 variable in BigEndian",
			args: args{
				arg:          []uint16{0x35, 0x08},
				littleEndian: false,
			},
			wantBuf: bytes.NewBuffer([]byte{
				0x00, 0x35,
				0x00, 0x08,
			}),
		},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			buf := new(bytes.Buffer)
			err := ToBinary(tt.args.arg, tt.args.littleEndian,
				buf)
			if (err != nil) != tt.wantErr {
				t.Errorf("ToBinary() error = %v, wantErr %v", err, tt.wantErr)
				return
			}
			if !reflect.DeepEqual(buf, tt.wantBuf) && !tt.wantErr {
				t.Errorf("ToBinary() = %v, want %v",
					buf.Bytes(), tt.wantBuf.Bytes())
			}
		})
	}
}

func TestFromBinary(t *testing.T) {
	type args struct {
		arg          any
		buf          *bytes.Buffer
		littleEndian bool
	}
	tests := []struct {
		name     string
		args     args
		wantErr  bool
		validate func(any) error
	}{
		{
			name: "Normal conversion of a uint32 variable",
			args: args{
				arg: new(uint32),
				buf: bytes.NewBuffer([]byte{
					0x08, 0x35, 0x00, 0x00,
				}),
				littleEndian: true,
			},
			validate: func(a any) error {
				v, ok := a.(*uint32)
				if !ok {
					return fmt.Errorf("type Error")
				}
				val := *v
				want := uint32(0x3508)
				if val != want {
					return fmt.Errorf("value error got %v want %v", val, want)
				}
				return nil
			},
		},
		{
			name: "Normal conversion of a float64 variable",
			args: args{
				arg: new(float64),
				buf: bytes.NewBuffer([]byte{
					0, 32, 125, 109, 22, 94, 66, 67,
				}),
				littleEndian: true,
			},
			validate: func(a any) error {
				v, ok := a.(*float64)
				if !ok {
					return fmt.Errorf("type Error")
				}
				val := *v
				want := float64(10.34e15)
				if val != want {
					return fmt.Errorf("value error got %v want %v", val, want)
				}
				return nil
			},
		},
		{
			name: "Negative for string variable",
			args: args{
				arg:          new(string),
				buf:          bytes.NewBuffer([]byte{}),
				littleEndian: true,
			},
			wantErr: true,
		},
		{
			name: "Negative Struct",
			args: args{
				arg: new(struct {
					s string
				}),
				buf:          bytes.NewBuffer([]byte{}),
				littleEndian: true,
			},
			wantErr: true,
		},
		{
			name: "Negative Map",
			args: args{
				arg:          new(map[int][]byte),
				buf:          bytes.NewBuffer([]byte{}),
				littleEndian: true,
			},
			wantErr: true,
		},
		{
			name: "Normal conversion of a uint32 variable in bigEndian",
			args: args{
				arg: new(uint32),
				buf: bytes.NewBuffer([]byte{
					0x00, 0x00, 0x35, 0x08,
				}),
				littleEndian: false,
			},
			validate: func(a any) error {
				v, ok := a.(*uint32)
				if !ok {
					return fmt.Errorf("type Error")
				}
				val := *v
				want := uint32(0x3508)
				if val != want {
					return fmt.Errorf("value error got %v want %v", val, want)
				}
				return nil
			},
		},
		{
			name: "Normal conversion of a []byte variable",
			args: args{
				arg: func() *[]byte {
					v := make([]byte, 2)
					return &v
				}(),
				buf:          bytes.NewBuffer([]byte{0x35, 0x08}),
				littleEndian: true,
			},
			validate: func(a any) error {
				v, ok := a.(*[]byte)
				if !ok {
					return fmt.Errorf("type Error")
				}
				val := *v
				want := []byte{0x35, 0x08}
				if !bytes.Equal(val, want) {
					return fmt.Errorf("value error got %v want %v", val, want)
				}
				return nil
			},
		},
		{
			name: "Normal conversion of a []uint32 variable",
			args: args{
				arg: func() *[]uint32 {
					v := make([]uint32, 2)
					return &v
				}(),
				buf: bytes.NewBuffer([]byte{
					0x35, 0x00, 0x00, 0x00,
					0x08, 0x00, 0x00, 0x00,
				}),
				littleEndian: true,
			},
			validate: func(a any) error {
				v, ok := a.(*[]uint32)
				if !ok {
					return fmt.Errorf("type Error")
				}
				val := *v
				want := []uint32{0x35, 0x08}
				if !reflect.DeepEqual(val, want) {
					return fmt.Errorf("value error got %v want %v", val, want)
				}
				return nil
			},
		},
		{
			name: "Normal conversion of a []uint16 variable in BigEndian",
			args: args{
				arg: func() *[]uint16 {
					v := make([]uint16, 2)
					return &v
				}(),
				buf: bytes.NewBuffer([]byte{
					0x00, 0x35,
					0x00, 0x08,
				}),
				littleEndian: false,
			},
			validate: func(a any) error {
				v, ok := a.(*[]uint16)
				if !ok {
					return fmt.Errorf("type Error")
				}
				val := *v
				want := []uint16{0x35, 0x08}
				if !reflect.DeepEqual(val, want) {
					return fmt.Errorf("value error got %v want %v", val, want)
				}
				return nil
			},
		},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			if err := FromBinary(tt.args.arg, tt.args.buf, tt.args.littleEndian); (err != nil) != tt.wantErr {
				t.Errorf("FromBinary() error = %v, wantErr %v", err, tt.wantErr)
				return
			}
			if !tt.wantErr {
				if err := tt.validate(tt.args.arg); err != nil {
					t.Errorf("FromBinary() return value error = %v", err)
				}
			}
		})
	}
}
data/values_byteslice.go000644 001750 001750 00000004240 14665105653 016137 0ustar00dev1729dev1729000000 000000 // Copyright (C) 2024 Abhijit Bose (aka. Boseji). All rights reserved.
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//    http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
// SPDX short identifier: Apache-2.0

package data

import (
	"fmt"
	"strings"
)

type ByteSlice struct {
	BS  []byte
	Tag string
}

const (
	byteSliceTypeSignature = "BS0"
	byteSliceMemberFormat  = "%x"
	byteSlicePrefix        = "["
	byteSliceSuffix        = "]"
	byteSliceSeparator     = " "
)

func (b ByteSlice) Type() string {
	return byteSliceTypeSignature
}

func (b ByteSlice) String() string {
	if len(b.BS) == 0 {
		return byteSlicePrefix + byteSliceSuffix
	}
	sa := make([]string, 0, len(b.BS))
	for _, i := range b.BS {
		sa = append(sa, fmt.Sprintf(byteSliceMemberFormat, i))
	}
	return byteSlicePrefix + strings.Join(sa, byteSliceSeparator) +
		byteSliceSuffix
}

func (b *ByteSlice) Recover(Type, Tag, Data string) error {
	if Type != byteSliceTypeSignature {
		return fmt.Errorf("invalid ByteSlice type")
	}
	b.Tag = Tag
	if !strings.HasPrefix(Data, byteSlicePrefix) ||
		!strings.HasSuffix(Data, byteSliceSuffix) {
		return fmt.Errorf("wrong ByteSlice format start or end")
	}
	s, _ := strings.CutPrefix(Data, byteSlicePrefix)
	s, _ = strings.CutSuffix(s, byteSliceSuffix)
	if len(s) == 0 {
		b.BS = []byte{}
		return nil
	}
	sa := strings.Split(s, byteSliceSeparator)
	val := make([]byte, len(sa))
	for iter, si := range sa {
		_, err := fmt.Sscanf(si, byteSliceMemberFormat, &val[iter])
		if err != nil {
			return fmt.Errorf("failed to recover ByteSlice due to %v at %v",
				err, iter)
		}
	}
	b.BS = val
	return nil
}

func (b ByteSlice) SetTag(s string) ByteSlice {
	b.Tag = s
	return b
}

func NewByteSlice(b []byte) ByteSlice {
	return ByteSlice{b, ""}
}
values/values_test.go000644 001750 001750 00000017452 14665232217 015527 0ustar00dev1729dev1729000000 000000 // Copyright (C) 2024 Abhijit Bose (aka. Boseji). All rights reserved.
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//    http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
// SPDX short identifier: Apache-2.0

package values

import "testing"

// Enclosed types

type encBool bool
type encInt int
type encInt8 int8
type encInt16 int16
type encInt32 int32
type encInt64 int64
type encUint uint
type encUint8 uint8
type encUint16 uint16
type encUint32 uint32
type encUint64 uint64
type encFloat32 float32
type encFloat64 float64

func TestDescribe(t *testing.T) {
	type args struct {
		u any
	}
	tests := []struct {
		name   string
		args   args
		wantBt BaseType
		wantCt ComposedType
	}{
		{
			name: "negative unknown interface type",
			args: args{
				u: any(nil),
			},
			wantBt: BaseInvalid,
			wantCt: ComposedBlankType,
		},
		{
			name: "bool type normal",
			args: args{
				u: true,
			},
			wantBt: BaseBool,
			wantCt: ComposedBlankType,
		},
		{
			name: "bool type pointer",
			args: args{
				u: new(bool),
			},
			wantBt: BaseBool,
			wantCt: ComposedBlankType,
		},
		{
			name: "negative bool type pointer nil",
			args: args{
				u: func() *bool {
					var v *bool
					return v
				}(),
			},
			wantBt: BaseInvalid,
			wantCt: ComposedBlankType,
		},
		{
			name: "bool type enclosed",
			args: args{
				u: encBool(true),
			},
			wantBt: BaseBool,
			wantCt: ComposedOverlay,
		},
		{
			name: "bool type enclosed pointer",
			args: args{
				u: new(encBool),
			},
			wantBt: BaseBool,
			wantCt: ComposedOverlay,
		},
		{
			name: "negative bool type enclosed pointer nil",
			args: args{
				u: func() *encBool {
					var v *encBool
					return v
				}(),
			},
			wantBt: BaseInvalid,
			wantCt: ComposedBlankType,
		},
		{
			name: "bool type slice",
			args: args{
				u: make([]bool, 1),
			},
			wantBt: BaseBool,
			wantCt: ComposedArray,
		},
		{
			name: "negative bool type pointer in slice",
			args: args{
				u: make([]*bool, 0),
			},
			wantBt: BaseInvalid,
			wantCt: ComposedBlankType,
		},
		{
			name: "bool enclosed type slice",
			args: args{
				u: make([]encBool, 1),
			},
			wantBt: BaseBool,
			wantCt: ComposedArray + ComposedOverlay,
		},
		{
			name: "negative bool enclosed pointer type slice",
			args: args{
				u: make([]*encBool, 0),
			},
			wantBt: BaseInvalid,
			wantCt: ComposedBlankType,
		},
		{
			name: "bool type Array",
			args: args{
				u: [1]bool{true},
			},
			wantBt: BaseBool,
			wantCt: ComposedArray,
		},
		{
			name: "negative bool pointer type Array",
			args: args{
				u: [1]*bool{new(bool)},
			},
			wantBt: BaseInvalid,
			wantCt: ComposedBlankType,
		},
		{
			name: "bool enclosed type Array",
			args: args{
				u: [1]encBool{true},
			},
			wantBt: BaseBool,
			wantCt: ComposedArray + ComposedOverlay,
		},
		{
			name: "negative bool enclosed pointer type Array",
			args: args{
				u: [1]*encBool{new(encBool)},
			},
			wantBt: BaseInvalid,
			wantCt: ComposedBlankType,
		},
		{
			name: "int type",
			args: args{
				u: int(-3),
			},
			wantBt: BaseInt64,
			wantCt: ComposedBlankType,
		},
		{
			name: "int type pointer",
			args: args{
				u: new(int),
			},
			wantBt: BaseInt64,
			wantCt: ComposedBlankType,
		},
		{
			name: "enclosed int type",
			args: args{
				u: encInt(-3),
			},
			wantBt: BaseInt64,
			wantCt: ComposedOverlay,
		},
		{
			name: "int8 type",
			args: args{
				u: int8(-3),
			},
			wantBt: BaseInt8,
			wantCt: ComposedBlankType,
		},
		{
			name: "enclosed int8 type",
			args: args{
				u: encInt8(-3),
			},
			wantBt: BaseInt8,
			wantCt: ComposedOverlay,
		},
		{
			name: "int16 type",
			args: args{
				u: int16(-3),
			},
			wantBt: BaseInt16,
			wantCt: ComposedBlankType,
		},
		{
			name: "enclosed int16 type",
			args: args{
				u: encInt16(-3),
			},
			wantBt: BaseInt16,
			wantCt: ComposedOverlay,
		},
		{
			name: "int32 type",
			args: args{
				u: int32(-3),
			},
			wantBt: BaseInt32,
			wantCt: ComposedBlankType,
		},
		{
			name: "enclosed int32 type",
			args: args{
				u: encInt32(-3),
			},
			wantBt: BaseInt32,
			wantCt: ComposedOverlay,
		},
		{
			name: "int64 type",
			args: args{
				u: int64(-3),
			},
			wantBt: BaseInt64,
			wantCt: ComposedBlankType,
		},
		{
			name: "enclosed int64 type",
			args: args{
				u: encInt64(-3),
			},
			wantBt: BaseInt64,
			wantCt: ComposedOverlay,
		},
		{
			name: "uint type",
			args: args{
				u: uint(3),
			},
			wantBt: BaseUint64,
			wantCt: ComposedBlankType,
		},
		{
			name: "enclosed uint type",
			args: args{
				u: encUint(3),
			},
			wantBt: BaseUint64,
			wantCt: ComposedOverlay,
		},
		{
			name: "uint8 type",
			args: args{
				u: uint8(3),
			},
			wantBt: BaseUint8,
			wantCt: ComposedBlankType,
		},
		{
			name: "enclosed uint8 type",
			args: args{
				u: encUint8(3),
			},
			wantBt: BaseUint8,
			wantCt: ComposedOverlay,
		},
		{
			name: "uint16 type",
			args: args{
				u: uint16(3),
			},
			wantBt: BaseUint16,
			wantCt: ComposedBlankType,
		},
		{
			name: "enclosed uint16 type",
			args: args{
				u: encUint16(3),
			},
			wantBt: BaseUint16,
			wantCt: ComposedOverlay,
		},
		{
			name: "uint32 type",
			args: args{
				u: uint32(3),
			},
			wantBt: BaseUint32,
			wantCt: ComposedBlankType,
		},
		{
			name: "enclosed uint32 type",
			args: args{
				u: encUint32(3),
			},
			wantBt: BaseUint32,
			wantCt: ComposedOverlay,
		},
		{
			name: "uint64 type",
			args: args{
				u: uint64(3),
			},
			wantBt: BaseUint64,
			wantCt: ComposedBlankType,
		},
		{
			name: "enclosed uint64 type",
			args: args{
				u: encUint64(3),
			},
			wantBt: BaseUint64,
			wantCt: ComposedOverlay,
		},
		{
			name: "Float32 type",
			args: args{
				u: float32(-3.2e5),
			},
			wantBt: BaseFloat32,
			wantCt: ComposedBlankType,
		},
		{
			name: "enclosed Float32 type",
			args: args{
				u: encFloat32(-3.2e5),
			},
			wantBt: BaseFloat32,
			wantCt: ComposedOverlay,
		},
		{
			name: "Float64 type",
			args: args{
				u: float64(-3.2e5),
			},
			wantBt: BaseFloat64,
			wantCt: ComposedBlankType,
		},
		{
			name: "enclosed Float64 type",
			args: args{
				u: encFloat64(-3.2e5),
			},
			wantBt: BaseFloat64,
			wantCt: ComposedOverlay,
		},
		{
			name: "Negative map type",
			args: args{
				u: map[string]string{},
			},
			wantBt: BaseInvalid,
			wantCt: ComposedBlankType,
		},
		{
			name: "Negative struct type",
			args: args{
				u: struct{ n int }{},
			},
			wantBt: BaseInvalid,
			wantCt: ComposedBlankType,
		},
		{
			name: "Negative Array pointer type",
			args: args{
				u: [2]*bool{new(bool), new(bool)},
			},
			wantBt: BaseInvalid,
			wantCt: ComposedBlankType,
		},
		{
			name: "Negative Slice pointer type",
			args: args{
				u: []*bool{new(bool), new(bool)},
			},
			wantBt: BaseInvalid,
			wantCt: ComposedBlankType,
		},
		{
			name: "Pointer to Array [2]bool type",
			args: args{
				u: func() *[2]bool {
					v := [2]bool{true, false}
					return &v
				}(),
			},
			wantBt: BaseBool,
			wantCt: ComposedArray,
		},
		{
			name: "Pointer to []bool Slice type",
			args: args{
				u: func() *[]bool {
					v := []bool{true, false}
					return &v
				}(),
			},
			wantBt: BaseBool,
			wantCt: ComposedArray,
		},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			gotBt, gotCt := Describe(tt.args.u)
			if gotBt != tt.wantBt {
				t.Errorf("Describe() gotBt = %v, want %v", gotBt, tt.wantBt)
			}
			if gotCt != tt.wantCt {
				t.Errorf("Describe() gotCt = %v, want %v", gotCt, tt.wantCt)
			}
		})
	}
}
data/values_bool_test.go000644 001750 001750 00000004671 14665100253 016145 0ustar00dev1729dev1729000000 000000 // Copyright (C) 2024 Abhijit Bose (aka. Boseji). All rights reserved.
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//    http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
// SPDX short identifier: Apache-2.0

package data

import (
	"reflect"
	"strings"
	"testing"
)

func Test_Bool(t *testing.T) {
	tests := []struct {
		name  string
		value Bool
		wantS string
		wantT string
	}{
		{
			name:  "Bool representation1",
			value: Bool{true, ""},
			wantS: "1",
			wantT: "B",
		},
		{
			name:  "Bool representation2",
			value: Bool{false, ""},
			wantS: "0",
			wantT: "B",
		},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			gotS := tt.value.String()
			gotT := tt.value.Type()
			if strings.Compare(gotS, tt.wantS) != 0 {
				t.Errorf("error in String got %v expected %v", gotS, tt.wantS)
				return
			}
			if strings.Compare(gotT, tt.wantT) != 0 {
				t.Errorf("error in Type got %v expected %v", gotT, tt.wantT)
			}
		})
	}
	tests2 := []struct {
		name    string
		argType string
		argTag  string
		argData string
		want    Bool
		wantErr bool
	}{
		{
			name:    "Bool recovery1",
			argType: boolTypeSignature,
			argTag:  "",
			argData: "1",
			want:    NewBool(true),
		},
		{
			name:    "Bool recovery2",
			argType: boolTypeSignature,
			argTag:  "valBit",
			argData: "0",
			want:    NewBool(false).SetTag("valBit"),
		},
		{
			name:    "Bool recovery Error1",
			argType: "k",
			argTag:  "valBit",
			argData: "0",
			wantErr: true,
		},
		{
			name:    "Bool recovery Error2",
			argType: boolTypeSignature,
			argTag:  "valBit",
			argData: "true",
			wantErr: true,
		},
	}
	for _, tt := range tests2 {
		t.Run(tt.name, func(t *testing.T) {
			b := NewBool(false)
			err := b.Recover(tt.argType, tt.argTag, tt.argData)
			if (err != nil) != tt.wantErr {
				t.Errorf("failed to Recover() error - %v want error %v",
					err, tt.wantErr)
				return
			}
			if !tt.wantErr && !reflect.DeepEqual(b, tt.want) {
				t.Errorf("value error got %#v expected %#v", b, tt.want)
			}
		})
	}
}
old-v1/string_format.go000644 001750 001750 00000003743 14665231753 015654 0ustar00dev1729dev1729000000 000000 // Copyright (C) 2024 Abhijit Bose (aka. Boseji). All rights reserved.
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//    http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
// SPDX short identifier: Apache-2.0

package tppi

import "fmt"

const (
	stringFormatMark = "S"
)

// StringFormat represents the data in their printable form
type StringFormat struct {
	Format string
}

// StringFormatOptions provides a way to configure the String formatter
type StringFormatOptions func(*StringFormat) *StringFormat

// Mark implements the Formatter interface for the StringFormat
func (sf StringFormat) Mark() string {
	return stringFormatMark
}

// Encode implements the Formatter interface for StringFormat
func (sf StringFormat) Encode(arg any) (s string, err error) {
	return fmt.Sprintf(sf.Format, arg), nil
}

// Decode implements the Formatter interface for StringFormat
func (sf StringFormat) Decode(arg any, s string) (val any, err error) {
	_, err = fmt.Sscanf(s, sf.Format, arg)
	val = arg
	return
}

// WithStringFormat allows to set custom String format for encoding and decoding
func WithStringFormat(s string) StringFormatOptions {
	return func(sf *StringFormat) *StringFormat {
		sf.Format = s
		return sf
	}
}

// defaultStringFormat setup the default String Format options
func defaultStringFormat() *StringFormat {
	return &StringFormat{
		Format: "%v",
	}
}

// NewStringFormat defines the String formatter
func NewStringFormat(op ...StringFormatOptions) Formatter {
	sf := defaultStringFormat()
	for _, o := range op {
		sf = o(sf)
	}
	return sf
}
old-v2/symbol.go000644 001750 001750 00000010653 14665232155 014277 0ustar00dev1729dev1729000000 000000 // Copyright (C) 2024 Abhijit Bose (aka. Boseji). All rights reserved.
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//    http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
// SPDX short identifier: Apache-2.0

package tppi

import (
	"fmt"
	"regexp"
	"strings"
)

// Protocol Level Symbol Constants
const (
	SYM_TILDE = "~"
	SYM_PIPE  = "|"
	SYM_START = "~|"
	SYM_END   = "|~"
)

// Protocol Separators
const (
	SEP_CONTENT = SYM_TILDE
	SEP_LINES   = SYM_PIPE
)

// Protocol Regex Filters
const (
	regexp_STUFF_PIPE     = `(?m)[\|]`
	regexp_STUFF_TILDE    = `(?m)[~]`
	replace_STUFF_PIPE    = `\x7C`
	replace_STUFF_TILDE   = `\x2D`
	regexp_UN_STUFF_PIPE  = `(?m)(\\x7C)`
	regexp_UN_STUFF_TILDE = `(?m)(\\x2D)`
	regexp_Stuffed        = `(?m)[\|~]`
)

// Stuff implements the Rules method to adds necessary
// protocol detection guards on a supplied content for TPPI protocol.
func Stuff(s string) (sv string, err error) {
	if len(s) == 0 {
		err = fmt.Errorf("no supplied parts to stuff")
		return
	}
	sv = strings.Clone(s)
	// Pipe Regex
	re := regexp.MustCompile(regexp_STUFF_PIPE)
	sv = re.ReplaceAllString(sv, replace_STUFF_PIPE)
	// Tilde Regex
	re = regexp.MustCompile(regexp_STUFF_TILDE)
	sv = re.ReplaceAllString(sv, replace_STUFF_TILDE)
	return
}

// UnStuff implements the Rules method to remove the protocol detection guards
// on the supplied content for TPPI protocol.
func UnStuff(s string) (sv string, err error) {
	if len(s) == 0 {
		err = fmt.Errorf("no supplied parts to un-stuff")
		return
	}
	sv = strings.Clone(s)
	// Pipe Regex
	re := regexp.MustCompile(regexp_UN_STUFF_PIPE)
	sv = re.ReplaceAllString(sv, SYM_PIPE)
	// Tilde Regex
	re = regexp.MustCompile(regexp_UN_STUFF_TILDE)
	sv = re.ReplaceAllString(sv, SYM_TILDE)
	return
}

// NeedsStuff reports if the supplied string contains Symbols that needs
// stuffing as per TPPI protocol.
// Returns True only if the has Symbols that needs stuffing.
func NeedsStuff(s string) bool {
	re := regexp.MustCompile(regexp_Stuffed)
	sa := re.FindAllString(s, -1)
	return (len(sa) > 0)
}

// JoinLines implements the CollectionRule method to help
// join multiple Lines together for TPPI protocol.
func JoinLines(sa ...string) (s string, err error) {
	if len(sa) == 0 {
		err = fmt.Errorf("no supplied parts to join lines")
		return
	}
	s = strings.Join(sa, SEP_LINES)
	return
}

// JoinContents implements the CollectionRule method to help join the contents
// into a single line for TPPI protocol.
func JoinContents(sa ...string) (s string, err error) {
	if len(sa) == 0 {
		err = fmt.Errorf("no supplied parts to join content")
		return
	}
	s = strings.Join(sa, SEP_CONTENT)
	return
}

// SplitLines implements the SplittingRule method to help break the provided
// packet into multiple lines for TPPI protocol.
func SplitLines(s string) (sa []string, err error) {
	if len(s) == 0 {
		err = fmt.Errorf("no string supplied to split into lines")
		return
	}
	sa = strings.Split(s, SEP_LINES)
	return
}

// SplitContents implements tge SplittingRule method to help break the
// provided line into its contents for TPPI protocol.
func SplitContents(s string) (sa []string, err error) {
	if len(s) == 0 {
		err = fmt.Errorf("no string supplied to split into content")
		return
	}
	sa = strings.Split(s, SEP_CONTENT)
	return
}

// AddStartEnd implements the Rules method that helps to add the framing
// for the protocol packet for TPPI protocol.
func AddStartEnd(s string) (sv string, err error) {
	if len(s) == 0 {
		err = fmt.Errorf("no string supplied to add start and end")
		return
	}
	sv = SYM_START + s + SYM_END
	return
}

// RemoveStartEnd implements the Rules method that helps to remove the framing
// for the protocol packet for TPPI protocol.
func RemoveStartEnd(s string) (sv string, err error) {
	if len(s) == 0 {
		err = fmt.Errorf("no string supplied to remove start and end")
		return
	}
	sv = strings.Clone(s)
	if strings.Contains(sv, SYM_START) {
		sv = strings.ReplaceAll(s, SYM_START, "")
	}
	if strings.Contains(sv, SYM_END) {
		sv = strings.ReplaceAll(sv, SYM_END, "")
	}
	return
}
old-v1/hex_format_test.go000644 001750 001750 00000013021 14665231657 016162 0ustar00dev1729dev1729000000 000000 // Copyright (C) 2024 Abhijit Bose (aka. Boseji). All rights reserved.
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//    http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
// SPDX short identifier: Apache-2.0

package tppi

import (
	"reflect"
	"testing"
)

func TestHexFormat_Encode(t *testing.T) {
	tests := []struct {
		name         string
		LittleEndian bool
		arg          any
		wantS        string
		wantErr      bool
	}{
		{
			name:         "Positive []byte slice",
			LittleEndian: true,
			arg: []byte{
				0x35, 0x08,
			},
			wantS: "3508",
		},
		{
			name:         "Positive string",
			LittleEndian: true,
			arg:          "Hare Krishna",
			wantS:        "48617265204b726973686e61",
		},
		{
			name:         "Positive uint32",
			LittleEndian: true,
			arg:          uint32(0x3508),
			wantS:        "08350000",
		},
		{
			name:         "Positive uint32 bigEndian",
			LittleEndian: false,
			arg:          uint32(0x3508),
			wantS:        "00003508",
		},
		{
			name:         "Positive float64",
			LittleEndian: true,
			arg:          float64(10.34e15),
			wantS:        "00207d6d165e4243",
		},
		{
			name:         "Positive float64 bigEndian",
			LittleEndian: false,
			arg:          float64(10.34e15),
			wantS:        "43425e166d7d2000",
		},
		{
			name:         "Positive bool",
			LittleEndian: true,
			arg:          false,
			wantS:        "00",
		},
		{
			name:         "Positive bool bigEndian",
			LittleEndian: false,
			arg:          true,
			wantS:        "01",
		},
		{
			name:         "Negative []string",
			LittleEndian: true,
			arg:          []string{"A", "B"},
			wantS:        "01",
			wantErr:      true,
		},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			h := HexFormat{
				LittleEndian: tt.LittleEndian,
			}
			gotS, err := h.Encode(tt.arg)
			if (err != nil) != tt.wantErr {
				t.Errorf("HexFormat.encode() error = %v, wantErr %v",
					err, tt.wantErr)
				return
			}
			if gotS != tt.wantS && !tt.wantErr {
				t.Errorf("HexFormat.encode() = %v, want %v", gotS, tt.wantS)
			}
		})
	}
}

func TestHexFormat_Decode(t *testing.T) {
	type args struct {
		arg any
		s   string
	}
	tests := []struct {
		name         string
		LittleEndian bool
		args         args
		wantVal      any
		wantErr      bool
	}{
		{
			name:         "Positive []byte slice",
			LittleEndian: true,
			args: args{
				arg: make([]byte, 1),
				s:   "3508",
			},
			wantVal: []byte{0x35, 0x08},
		},
		{
			name:         "Positive string",
			LittleEndian: true,
			args: args{
				arg: "",
				s:   "48617265204b726973686e61",
			},
			wantVal: "Hare Krishna",
		},
		{
			name:         "Positive uint32",
			LittleEndian: true,
			args: args{
				arg: new(uint32),
				s:   "08350000",
			},
			wantVal: func() *uint32 {
				var v uint32 = 0x3508
				return &v
			}(),
		},
		{
			name:         "Positive uint32 bigEndian",
			LittleEndian: false,
			args: args{
				arg: new(uint32),
				s:   "00003508",
			},
			wantVal: func() *uint32 {
				var v uint32 = 0x3508
				return &v
			}(),
		},
		{
			name:         "Positive float64",
			LittleEndian: true,
			args: args{
				arg: new(float64),
				s:   "00207d6d165e4243",
			},
			wantVal: func() *float64 {
				var v float64 = 10.34e15
				return &v
			}(),
		},
		{
			name:         "Positive float64 bigEndian",
			LittleEndian: false,
			args: args{
				arg: new(float64),
				s:   "43425e166d7d2000",
			},
			wantVal: func() *float64 {
				var v float64 = 10.34e15
				return &v
			}(),
		},
		{
			name:         "Positive bool",
			LittleEndian: true,
			args: args{
				arg: new(bool),
				s:   "00",
			},
			wantVal: func() *bool {
				var v bool = false
				return &v
			}(),
		},
		{
			name:         "Positive bool bigEndian",
			LittleEndian: false,
			args: args{
				arg: new(bool),
				s:   "01",
			},
			wantVal: func() *bool {
				var v bool = true
				return &v
			}(),
		},
		{
			name:         "Negative []string",
			LittleEndian: true,
			args: args{
				arg: []string{"A", "B"},
				s:   "AB",
			},
			wantVal: nil,
			wantErr: true,
		},
		{
			name:         "Negative uint32 with wrong data",
			LittleEndian: true,
			args: args{
				arg: new(uint32),
				s:   "AB-+02",
			},
			wantVal: nil,
			wantErr: true,
		},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			h := HexFormat{
				LittleEndian: tt.LittleEndian,
			}
			gotVal, err := h.Decode(tt.args.arg, tt.args.s)
			if (err != nil) != tt.wantErr {
				t.Errorf("HexFormat.decode() error = %v, wantErr %v", err, tt.wantErr)
				return
			}
			if !reflect.DeepEqual(gotVal, tt.wantVal) {
				t.Errorf("HexFormat.decode() = %v, want %v", gotVal, tt.wantVal)
			}
		})
	}
}

func TestHexFormat_others(t *testing.T) {
	t.Run("mark and new test", func(t *testing.T) {
		h := NewHexFormat()
		if hf, ok := h.(HexFormat); ok && hf.LittleEndian != true {
			t.Errorf("Failed to setup the HexFormat")
		}
		if h.Mark() != hexFormatMark {
			t.Errorf("Failed to get correct mark for HexFormat")
		}
		h1 := NewHexFormat(WithHexFormatInBigEndian())
		if hf, ok := h1.(HexFormat); ok && hf.LittleEndian != false {
			t.Errorf("Failed to setup the HexFormat in BigEndian")
		}
	})
}
old-v2/symbol_test.go000644 001750 001750 00000020573 14665232142 015334 0ustar00dev1729dev1729000000 000000 // Copyright (C) 2024 Abhijit Bose (aka. Boseji). All rights reserved.
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//    http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
// SPDX short identifier: Apache-2.0

package tppi

import (
	"reflect"
	"testing"
)

func TestIsStuffed(t *testing.T) {
	tests := []struct {
		name string
		args string
		want bool
	}{
		{
			name: "un-stuffed",
			args: "||Hare Krishna ~",
			want: true,
		},
		{
			name: "stuffed",
			args: "\\x7CHare Krishna \\x2D",
			want: false,
		},
		{
			name: "NoStuff Needed",
			args: "Hare Krishna",
			want: false,
		},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			if got := NeedsStuff(tt.args); got != tt.want {
				t.Errorf("IsStuffed() = %v, want %v", got, tt.want)
			}
		})
	}
}

func TestStuff(t *testing.T) {
	type args struct {
		s string
	}
	tests := []struct {
		name    string
		args    args
		wantSv  string
		wantErr bool
	}{
		{
			name: "Negative Empty string",
			args: args{
				"",
			},
			wantErr: true,
		},
		{
			name: "Positive with one Pipe",
			args: args{
				"Hare |Krishna",
			},
			wantSv: "Hare \\x7CKrishna",
		},
		{
			name: "Positive with double Pipe combo",
			args: args{
				"Hare ||Krishna|",
			},
			wantSv: "Hare \\x7C\\x7CKrishna\\x7C",
		},
		{
			name: "Positive with one Pipe + tilde combo",
			args: args{
				"~Hare |Kri~~shna",
			},
			wantSv: "\\x2DHare \\x7CKri\\x2D\\x2Dshna",
		},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			gotSv, err := Stuff(tt.args.s)
			if (err != nil) != tt.wantErr {
				t.Errorf("Stuff() error = %v, wantErr %v", err, tt.wantErr)
				return
			}
			if gotSv != tt.wantSv {
				t.Errorf("Stuff() = %v, want %v", gotSv, tt.wantSv)
			}
		})
	}
}

func TestUnStuff(t *testing.T) {
	type args struct {
		s string
	}
	tests := []struct {
		name    string
		args    args
		wantSv  string
		wantErr bool
	}{
		{
			name: "Negative Empty string",
			args: args{
				"",
			},
			wantErr: true,
		},
		{
			name: "Positive with one Pipe",
			args: args{
				"Hare \\x7CKrishna",
			},
			wantSv: "Hare |Krishna",
		},
		{
			name: "Positive with double Pipe combo",
			args: args{
				"Hare \\x7C\\x7CKrishna\\x7C",
			},
			wantSv: "Hare ||Krishna|",
		},
		{
			name: "Positive with one Pipe + tilde combo",
			args: args{
				"\\x2DHare \\x7CKri\\x2D\\x2Dshna",
			},
			wantSv: "~Hare |Kri~~shna",
		},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			gotSv, err := UnStuff(tt.args.s)
			if (err != nil) != tt.wantErr {
				t.Errorf("UnStuff() error = %v, wantErr %v", err, tt.wantErr)
				return
			}
			if gotSv != tt.wantSv {
				t.Errorf("UnStuff() = %v, want %v", gotSv, tt.wantSv)
			}
		})
	}
}

func TestJoinLines(t *testing.T) {
	type args struct {
		sa []string
	}
	tests := []struct {
		name    string
		args    args
		wantS   string
		wantErr bool
	}{
		{
			name: "Negative blank input",
			args: args{
				sa: nil,
			},
			wantErr: true,
		},
		{
			name: "Positive Single string",
			args: args{
				sa: []string{
					"Hare Krishna",
				},
			},
			wantS: "Hare Krishna",
		},
		{
			name: "Positive Multiple string",
			args: args{
				sa: []string{
					"Hare Krishna",
					"Hare Krishna",
				},
			},
			wantS: "Hare Krishna|Hare Krishna",
		},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			gotS, err := JoinLines(tt.args.sa...)
			if (err != nil) != tt.wantErr {
				t.Errorf("JoinLines() error = %v, wantErr %v", err, tt.wantErr)
				return
			}
			if gotS != tt.wantS {
				t.Errorf("JoinLines() = %v, want %v", gotS, tt.wantS)
			}
		})
	}
}

func TestJoinContents(t *testing.T) {
	type args struct {
		sa []string
	}
	tests := []struct {
		name    string
		args    args
		wantS   string
		wantErr bool
	}{
		{
			name: "Negative blank input",
			args: args{
				sa: nil,
			},
			wantErr: true,
		},
		{
			name: "Positive Single string",
			args: args{
				sa: []string{
					"Hare Krishna",
				},
			},
			wantS: "Hare Krishna",
		},
		{
			name: "Positive Multiple string",
			args: args{
				sa: []string{
					"Hare Krishna",
					"Hare Krishna",
				},
			},
			wantS: "Hare Krishna~Hare Krishna",
		},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			gotS, err := JoinContents(tt.args.sa...)
			if (err != nil) != tt.wantErr {
				t.Errorf("JoinContents() error = %v, wantErr %v", err, tt.wantErr)
				return
			}
			if gotS != tt.wantS {
				t.Errorf("JoinContents() = %v, want %v", gotS, tt.wantS)
			}
		})
	}
}

func TestSplitLines(t *testing.T) {
	type args struct {
		s string
	}
	tests := []struct {
		name    string
		args    args
		wantSa  []string
		wantErr bool
	}{
		{
			name: "Negative Empty string",
			args: args{
				s: "",
			},
			wantSa:  nil,
			wantErr: true,
		},
		{
			name: "Positive Single string",
			args: args{
				s: "Hare Krishna",
			},
			wantSa: []string{"Hare Krishna"},
		},
		{
			name: "Positive Multiple string",
			args: args{
				s: "Hare Krishna|Hare Ram|Hare Hare",
			},
			wantSa: []string{
				"Hare Krishna",
				"Hare Ram",
				"Hare Hare",
			},
		},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			gotSa, err := SplitLines(tt.args.s)
			if (err != nil) != tt.wantErr {
				t.Errorf("SplitLines() error = %v, wantErr %v", err, tt.wantErr)
				return
			}
			if !reflect.DeepEqual(gotSa, tt.wantSa) {
				t.Errorf("SplitLines() = %v, want %v", gotSa, tt.wantSa)
			}
		})
	}
}

func TestSplitContents(t *testing.T) {
	type args struct {
		s string
	}
	tests := []struct {
		name    string
		args    args
		wantSa  []string
		wantErr bool
	}{
		{
			name: "Negative Empty string",
			args: args{
				s: "",
			},
			wantSa:  nil,
			wantErr: true,
		},
		{
			name: "Positive Single string",
			args: args{
				s: "Hare Krishna",
			},
			wantSa: []string{"Hare Krishna"},
		},
		{
			name: "Positive Multiple string",
			args: args{
				s: "Hare Krishna~Hare Ram~Hare Hare",
			},
			wantSa: []string{
				"Hare Krishna",
				"Hare Ram",
				"Hare Hare",
			},
		},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			gotSa, err := SplitContents(tt.args.s)
			if (err != nil) != tt.wantErr {
				t.Errorf("SplitContents() error = %v, wantErr %v", err, tt.wantErr)
				return
			}
			if !reflect.DeepEqual(gotSa, tt.wantSa) {
				t.Errorf("SplitContents() = %v, want %v", gotSa, tt.wantSa)
			}
		})
	}
}

func TestAddStartEnd(t *testing.T) {
	type args struct {
		s string
	}
	tests := []struct {
		name    string
		args    args
		wantSv  string
		wantErr bool
	}{
		{
			name: "Negative Blank input",
			args: args{
				s: "",
			},
			wantErr: true,
		},
		{
			name: "Positive in Short String",
			args: args{
				s: "Hare Krishna",
			},
			wantSv: "~|Hare Krishna|~",
		},
		{
			name: "Positive in Longer String",
			args: args{
				s: "Hare Krishna|Hare Ram",
			},
			wantSv: "~|Hare Krishna|Hare Ram|~",
		},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			gotSv, err := AddStartEnd(tt.args.s)
			if (err != nil) != tt.wantErr {
				t.Errorf("AddStartEnd() error = %v, wantErr %v", err, tt.wantErr)
				return
			}
			if gotSv != tt.wantSv {
				t.Errorf("AddStartEnd() = %v, want %v", gotSv, tt.wantSv)
			}
		})
	}
}

func TestRemoveStartEnd(t *testing.T) {
	type args struct {
		s string
	}
	tests := []struct {
		name    string
		args    args
		wantSv  string
		wantErr bool
	}{
		{
			name: "Negative Blank input",
			args: args{
				s: "",
			},
			wantErr: true,
		},
		{
			name: "Positive in Short String",
			args: args{
				s: "~|Hare Krishna|~",
			},
			wantSv: "Hare Krishna",
		},
		{
			name: "Positive in Longer String",
			args: args{
				s: "~|Hare Krishna|Hare Ram|~",
			},
			wantSv: "Hare Krishna|Hare Ram",
		},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			gotSv, err := RemoveStartEnd(tt.args.s)
			if (err != nil) != tt.wantErr {
				t.Errorf("RemoveStartEnd() error = %v, wantErr %v", err, tt.wantErr)
				return
			}
			if gotSv != tt.wantSv {
				t.Errorf("RemoveStartEnd() = %v, want %v", gotSv, tt.wantSv)
			}
		})
	}
}
old-v1/binary_test.go000644 001750 001750 00000007737 14665231643 015326 0ustar00dev1729dev1729000000 000000 // Copyright (C) 2024 Abhijit Bose (aka. Boseji). All rights reserved.
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//    http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
// SPDX short identifier: Apache-2.0

package tppi

import (
	"bytes"
	"reflect"
	"testing"
)

func TestToBinary(t *testing.T) {
	type args struct {
		arg          any
		littleEndian bool
	}
	tests := []struct {
		name    string
		args    args
		wantBuf *bytes.Buffer
		wantErr bool
	}{
		{
			name: "Normal conversion of a uint32 variable",
			args: args{
				arg:          uint32(0x3508),
				littleEndian: true,
			},
			wantBuf: bytes.NewBuffer([]byte{
				0x08, 0x35, 0x00, 0x00,
			}),
		},
		{
			name: "Normal conversion of a float64 variable",
			args: args{
				arg:          float64(10.34e15),
				littleEndian: true,
			},
			wantBuf: bytes.NewBuffer([]byte{
				0, 32, 125, 109, 22, 94, 66, 67,
			}),
		},
		{
			name: "Negative for string variable",
			args: args{
				arg:          "Testing String",
				littleEndian: true,
			},
			wantBuf: bytes.NewBuffer([]byte{}),
			wantErr: true,
		},
		{
			name: "Negative Struct variable with variable fields",
			args: args{
				arg: struct {
					i uint16
					v float32
					b uint8
					s string
				}{
					i: 0x3508,
					v: 12.5,
					b: 23,
					s: "Hari Aum",
				},
				littleEndian: true,
			},
			wantBuf: bytes.NewBuffer([]byte{}),
			wantErr: true,
		},
		{
			name: "Conversion of a Struct variable with Fixed length fields",
			args: args{
				arg: struct {
					i uint16
					v float32
					b uint8
				}{
					i: 0x3508,
					v: 12.5,
					b: 23,
				},
				littleEndian: true,
			},
			wantBuf: bytes.NewBuffer([]byte{8, 53, 0, 0, 72, 65, 23}),
		},
		{
			name: "Normal conversion of a uint32 variable in bigEndian",
			args: args{
				arg:          uint32(0x3508),
				littleEndian: false,
			},
			wantBuf: bytes.NewBuffer([]byte{
				0x00, 0x00, 0x35, 0x08,
			}),
		},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			buf := new(bytes.Buffer)
			err := ToBinary(tt.args.arg, tt.args.littleEndian,
				buf)
			if (err != nil) != tt.wantErr {
				t.Errorf("ToBinary() error = %v, wantErr %v", err, tt.wantErr)
				return
			}
			if !reflect.DeepEqual(buf, tt.wantBuf) && !tt.wantErr {
				t.Errorf("ToBinary() = %v, want %v",
					buf.Bytes(), tt.wantBuf.Bytes())
			}
		})
	}
}

func TestFromBinary(t *testing.T) {
	t.Run("Normal conversion of a uint32 variable", func(t *testing.T) {
		var v, o uint32 = 0, 0x3508
		buf := bytes.NewBuffer([]byte{0x08, 0x35, 0x00, 0x00})
		err := FromBinary(&v, buf, true)
		if err != nil {
			t.Errorf("FromBinary() error = %v", err)
		}

		if v != o {
			t.Errorf("Expected %v got %v", o, v)
		}
	})
	t.Run("Normal conversion of a float64 variable", func(t *testing.T) {
		var v, o float64 = 0, float64(10.34e15)
		buf := bytes.NewBuffer([]byte{0, 32, 125, 109, 22, 94, 66, 67})
		err := FromBinary(&v, buf, true)
		if err != nil {
			t.Errorf("FromBinary() error = %v", err)
		}

		if v != o {
			t.Errorf("Expected %v got %v", o, v)
		}
	})
	t.Run("Negative conversion of a string variable", func(t *testing.T) {
		var v string = ""
		buf := bytes.NewBuffer([]byte{})
		err := FromBinary(v, buf, true)
		if err == nil {
			t.Errorf("FromBinary() No error")
		}
	})
	t.Run("BigEndian conversion of a uint32 variable", func(t *testing.T) {
		var v, o uint32 = 0, 0x3508
		buf := bytes.NewBuffer([]byte{0x00, 0x00, 0x35, 0x08})
		err := FromBinary(&v, buf, false)
		if err != nil {
			t.Errorf("FromBinary() error = %v", err)
		}

		if v != o {
			t.Errorf("Expected %v got %v", o, v)
		}
	})
}
old-v2/000755 001750 001750 00000000000 14664537202 012436 5ustar00dev1729dev1729000000 000000 data/values_int.go000644 001750 001750 00000002470 14665100144 014737 0ustar00dev1729dev1729000000 000000 // Copyright (C) 2024 Abhijit Bose (aka. Boseji). All rights reserved.
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//    http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
// SPDX short identifier: Apache-2.0

package data

import (
	"fmt"
	"strings"
)

type Int struct {
	int
	Tag string
}

const (
	intTypeSignature = "I0"
	intFormat        = "%x"
)

func (i Int) Type() string {
	return intTypeSignature
}

func (i Int) String() string {
	return fmt.Sprintf(intFormat, i.int)
}

func (i *Int) Recover(Type, Tag, Data string) error {
	if Type != intTypeSignature {
		return fmt.Errorf("invalid int type")
	}
	i.Tag = Tag
	_, err := fmt.Sscanf(strings.TrimSpace(Data), intFormat, &i.int)
	if err != nil {
		return fmt.Errorf("invalid int data - %v", err)
	}
	return nil
}

func (i Int) SetTag(s string) Int {
	i.Tag = s
	return i
}

func NewInt(i int) Int {
	return Int{i, ""}
}
data/values_bool.go000644 001750 001750 00000002562 14665075575 015125 0ustar00dev1729dev1729000000 000000 // Copyright (C) 2024 Abhijit Bose (aka. Boseji). All rights reserved.
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//    http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
// SPDX short identifier: Apache-2.0

package data

import "fmt"

type Bool struct {
	bool
	Tag string
}

const (
	boolTypeSignature = "B"
	boolDataTrue      = "1"
	boolDataFalse     = "0"
)

func (b Bool) Type() string {
	return boolTypeSignature
}

func (b Bool) String() string {
	if b.bool {
		return boolDataTrue
	}
	return boolDataFalse
}

func (b *Bool) Recover(Type, Tag, Data string) error {
	if Type != boolTypeSignature {
		return fmt.Errorf("invalid bool type")
	}
	b.Tag = Tag
	if Data == boolDataTrue {
		b.bool = true
	} else if Data == boolDataFalse {
		b.bool = false
	} else {
		return fmt.Errorf("invalid bool data")
	}
	return nil
}

func (b Bool) SetTag(s string) Bool {
	b.Tag = s
	return b
}

func NewBool(b bool) Bool {
	return Bool{b, ""}
}
data/000755 001750 001750 00000000000 14665105463 012245 5ustar00dev1729dev1729000000 000000 old-v1/hex_format.go000644 001750 001750 00000005135 14665231731 015123 0ustar00dev1729dev1729000000 000000 // Copyright (C) 2024 Abhijit Bose (aka. Boseji). All rights reserved.
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//    http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
// SPDX short identifier: Apache-2.0

package tppi

import (
	"bytes"
	"encoding/hex"
	"fmt"
)

const (
	hexFormatMark = "H"
)

// HexFormat is the Hex Format Encoding and Decoding Handlers
type HexFormat struct {
	LittleEndian bool
}

// HexFormatOptions helps to setup the HexFormat Formatter
type HexFormatOptions func(*HexFormat) *HexFormat

// Mark implements the Formatter interface for the HexFormat
func (h HexFormat) Mark() string {
	return hexFormatMark
}

// Encode implements the Formatter interface for HexFormat
func (h HexFormat) Encode(arg any) (s string, err error) {
	buf := new(bytes.Buffer)
	switch v := arg.(type) {
	case []byte:
		buf.Write(v)
	case string:
		buf.WriteString(v)
	default:
		err = ToBinary(arg, h.LittleEndian, buf)
		if err != nil {
			err = fmt.Errorf("failed to hex encode: %v", err)
			return
		}
	}
	// Perform Hex encoding
	s = hex.EncodeToString(buf.Bytes())
	return
}

// Decode implements the Formatter interface for HexFormat
func (h HexFormat) Decode(arg any, s string) (val any, err error) {
	bs, err := hex.DecodeString(s)
	if err != nil {
		err = fmt.Errorf("failed to hex decode string: %v", err)
		return
	}
	switch v := arg.(type) {
	case string:
		val = string(bs)
		return
	case []byte:
		val = bs
		return
	default:
		buf := bytes.NewBuffer(bs)
		err = FromBinary(arg, buf, h.LittleEndian)
		_ = v
	}

	if err != nil {
		err = fmt.Errorf("failed to hex decode and convert to data type: %v",
			err)
		return
	}
	val = arg
	return
}

// WithHexFormatInBigEndian helps to setup BigEndian system
func WithHexFormatInBigEndian() HexFormatOptions {
	return func(hf *HexFormat) *HexFormat {
		hf.LittleEndian = false
		return hf
	}
}

// defaultHexFormat is the default options for the HexFormat
func defaultHexFormat() *HexFormat {
	return &HexFormat{LittleEndian: true}
}

// NewHexFormat creates a new HexFormat encoder/decoder for data
func NewHexFormat(op ...HexFormatOptions) Formatter {
	hf := defaultHexFormat()
	for _, o := range op {
		hf = o(hf)
	}
	return hf
}
old-v2/binary_endian_little.go000644 001750 001750 00000001733 14665232103 017141 0ustar00dev1729dev1729000000 000000 // Copyright (C) 2024 Abhijit Bose (aka. Boseji). All rights reserved.
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//    http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
// SPDX short identifier: Apache-2.0

//go:build 386 || amd64 || amd64p32 || alpha || arm || arm64 || loong64 || mipsle || mips64le || mips64p32le || nios2 || ppc64le || riscv || riscv64 || sh || wasm

package tppi

// IsLittleEndian helps to determine if the Machine architecture is
// Little Endian or Big Endian
func IsLittleEndian() bool {
	return true
}
old-v1/symbol_test.go000644 001750 001750 00000020573 14665231761 015341 0ustar00dev1729dev1729000000 000000 // Copyright (C) 2024 Abhijit Bose (aka. Boseji). All rights reserved.
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//    http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
// SPDX short identifier: Apache-2.0

package tppi

import (
	"reflect"
	"testing"
)

func TestIsStuffed(t *testing.T) {
	tests := []struct {
		name string
		args string
		want bool
	}{
		{
			name: "un-stuffed",
			args: "||Hare Krishna ~",
			want: true,
		},
		{
			name: "stuffed",
			args: "\\x7CHare Krishna \\x2D",
			want: false,
		},
		{
			name: "NoStuff Needed",
			args: "Hare Krishna",
			want: false,
		},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			if got := NeedsStuff(tt.args); got != tt.want {
				t.Errorf("IsStuffed() = %v, want %v", got, tt.want)
			}
		})
	}
}

func TestStuff(t *testing.T) {
	type args struct {
		s string
	}
	tests := []struct {
		name    string
		args    args
		wantSv  string
		wantErr bool
	}{
		{
			name: "Negative Empty string",
			args: args{
				"",
			},
			wantErr: true,
		},
		{
			name: "Positive with one Pipe",
			args: args{
				"Hare |Krishna",
			},
			wantSv: "Hare \\x7CKrishna",
		},
		{
			name: "Positive with double Pipe combo",
			args: args{
				"Hare ||Krishna|",
			},
			wantSv: "Hare \\x7C\\x7CKrishna\\x7C",
		},
		{
			name: "Positive with one Pipe + tilde combo",
			args: args{
				"~Hare |Kri~~shna",
			},
			wantSv: "\\x2DHare \\x7CKri\\x2D\\x2Dshna",
		},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			gotSv, err := Stuff(tt.args.s)
			if (err != nil) != tt.wantErr {
				t.Errorf("Stuff() error = %v, wantErr %v", err, tt.wantErr)
				return
			}
			if gotSv != tt.wantSv {
				t.Errorf("Stuff() = %v, want %v", gotSv, tt.wantSv)
			}
		})
	}
}

func TestUnStuff(t *testing.T) {
	type args struct {
		s string
	}
	tests := []struct {
		name    string
		args    args
		wantSv  string
		wantErr bool
	}{
		{
			name: "Negative Empty string",
			args: args{
				"",
			},
			wantErr: true,
		},
		{
			name: "Positive with one Pipe",
			args: args{
				"Hare \\x7CKrishna",
			},
			wantSv: "Hare |Krishna",
		},
		{
			name: "Positive with double Pipe combo",
			args: args{
				"Hare \\x7C\\x7CKrishna\\x7C",
			},
			wantSv: "Hare ||Krishna|",
		},
		{
			name: "Positive with one Pipe + tilde combo",
			args: args{
				"\\x2DHare \\x7CKri\\x2D\\x2Dshna",
			},
			wantSv: "~Hare |Kri~~shna",
		},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			gotSv, err := UnStuff(tt.args.s)
			if (err != nil) != tt.wantErr {
				t.Errorf("UnStuff() error = %v, wantErr %v", err, tt.wantErr)
				return
			}
			if gotSv != tt.wantSv {
				t.Errorf("UnStuff() = %v, want %v", gotSv, tt.wantSv)
			}
		})
	}
}

func TestJoinLines(t *testing.T) {
	type args struct {
		sa []string
	}
	tests := []struct {
		name    string
		args    args
		wantS   string
		wantErr bool
	}{
		{
			name: "Negative blank input",
			args: args{
				sa: nil,
			},
			wantErr: true,
		},
		{
			name: "Positive Single string",
			args: args{
				sa: []string{
					"Hare Krishna",
				},
			},
			wantS: "Hare Krishna",
		},
		{
			name: "Positive Multiple string",
			args: args{
				sa: []string{
					"Hare Krishna",
					"Hare Krishna",
				},
			},
			wantS: "Hare Krishna|Hare Krishna",
		},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			gotS, err := JoinLines(tt.args.sa...)
			if (err != nil) != tt.wantErr {
				t.Errorf("JoinLines() error = %v, wantErr %v", err, tt.wantErr)
				return
			}
			if gotS != tt.wantS {
				t.Errorf("JoinLines() = %v, want %v", gotS, tt.wantS)
			}
		})
	}
}

func TestJoinContents(t *testing.T) {
	type args struct {
		sa []string
	}
	tests := []struct {
		name    string
		args    args
		wantS   string
		wantErr bool
	}{
		{
			name: "Negative blank input",
			args: args{
				sa: nil,
			},
			wantErr: true,
		},
		{
			name: "Positive Single string",
			args: args{
				sa: []string{
					"Hare Krishna",
				},
			},
			wantS: "Hare Krishna",
		},
		{
			name: "Positive Multiple string",
			args: args{
				sa: []string{
					"Hare Krishna",
					"Hare Krishna",
				},
			},
			wantS: "Hare Krishna~Hare Krishna",
		},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			gotS, err := JoinContents(tt.args.sa...)
			if (err != nil) != tt.wantErr {
				t.Errorf("JoinContents() error = %v, wantErr %v", err, tt.wantErr)
				return
			}
			if gotS != tt.wantS {
				t.Errorf("JoinContents() = %v, want %v", gotS, tt.wantS)
			}
		})
	}
}

func TestSplitLines(t *testing.T) {
	type args struct {
		s string
	}
	tests := []struct {
		name    string
		args    args
		wantSa  []string
		wantErr bool
	}{
		{
			name: "Negative Empty string",
			args: args{
				s: "",
			},
			wantSa:  nil,
			wantErr: true,
		},
		{
			name: "Positive Single string",
			args: args{
				s: "Hare Krishna",
			},
			wantSa: []string{"Hare Krishna"},
		},
		{
			name: "Positive Multiple string",
			args: args{
				s: "Hare Krishna|Hare Ram|Hare Hare",
			},
			wantSa: []string{
				"Hare Krishna",
				"Hare Ram",
				"Hare Hare",
			},
		},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			gotSa, err := SplitLines(tt.args.s)
			if (err != nil) != tt.wantErr {
				t.Errorf("SplitLines() error = %v, wantErr %v", err, tt.wantErr)
				return
			}
			if !reflect.DeepEqual(gotSa, tt.wantSa) {
				t.Errorf("SplitLines() = %v, want %v", gotSa, tt.wantSa)
			}
		})
	}
}

func TestSplitContents(t *testing.T) {
	type args struct {
		s string
	}
	tests := []struct {
		name    string
		args    args
		wantSa  []string
		wantErr bool
	}{
		{
			name: "Negative Empty string",
			args: args{
				s: "",
			},
			wantSa:  nil,
			wantErr: true,
		},
		{
			name: "Positive Single string",
			args: args{
				s: "Hare Krishna",
			},
			wantSa: []string{"Hare Krishna"},
		},
		{
			name: "Positive Multiple string",
			args: args{
				s: "Hare Krishna~Hare Ram~Hare Hare",
			},
			wantSa: []string{
				"Hare Krishna",
				"Hare Ram",
				"Hare Hare",
			},
		},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			gotSa, err := SplitContents(tt.args.s)
			if (err != nil) != tt.wantErr {
				t.Errorf("SplitContents() error = %v, wantErr %v", err, tt.wantErr)
				return
			}
			if !reflect.DeepEqual(gotSa, tt.wantSa) {
				t.Errorf("SplitContents() = %v, want %v", gotSa, tt.wantSa)
			}
		})
	}
}

func TestAddStartEnd(t *testing.T) {
	type args struct {
		s string
	}
	tests := []struct {
		name    string
		args    args
		wantSv  string
		wantErr bool
	}{
		{
			name: "Negative Blank input",
			args: args{
				s: "",
			},
			wantErr: true,
		},
		{
			name: "Positive in Short String",
			args: args{
				s: "Hare Krishna",
			},
			wantSv: "~|Hare Krishna|~",
		},
		{
			name: "Positive in Longer String",
			args: args{
				s: "Hare Krishna|Hare Ram",
			},
			wantSv: "~|Hare Krishna|Hare Ram|~",
		},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			gotSv, err := AddStartEnd(tt.args.s)
			if (err != nil) != tt.wantErr {
				t.Errorf("AddStartEnd() error = %v, wantErr %v", err, tt.wantErr)
				return
			}
			if gotSv != tt.wantSv {
				t.Errorf("AddStartEnd() = %v, want %v", gotSv, tt.wantSv)
			}
		})
	}
}

func TestRemoveStartEnd(t *testing.T) {
	type args struct {
		s string
	}
	tests := []struct {
		name    string
		args    args
		wantSv  string
		wantErr bool
	}{
		{
			name: "Negative Blank input",
			args: args{
				s: "",
			},
			wantErr: true,
		},
		{
			name: "Positive in Short String",
			args: args{
				s: "~|Hare Krishna|~",
			},
			wantSv: "Hare Krishna",
		},
		{
			name: "Positive in Longer String",
			args: args{
				s: "~|Hare Krishna|Hare Ram|~",
			},
			wantSv: "Hare Krishna|Hare Ram",
		},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			gotSv, err := RemoveStartEnd(tt.args.s)
			if (err != nil) != tt.wantErr {
				t.Errorf("RemoveStartEnd() error = %v, wantErr %v", err, tt.wantErr)
				return
			}
			if gotSv != tt.wantSv {
				t.Errorf("RemoveStartEnd() = %v, want %v", gotSv, tt.wantSv)
			}
		})
	}
}
old-v1/000755 001750 001750 00000000000 14664067311 012434 5ustar00dev1729dev1729000000 000000 old-v1/protocol.go000644 001750 001750 00000010130 14665231703 014616 0ustar00dev1729dev1729000000 000000 // Copyright (C) 2024 Abhijit Bose (aka. Boseji). All rights reserved.
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//    http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
// SPDX short identifier: Apache-2.0

package tppi

import (
	"fmt"
	"strings"
)

// Protocol describes the contents in the TPPI packet constrained by the
// Various input requirements.
type Protocol struct {
	StartStop   bool    // Needs the Start and Stop Symbols or Not
	Liner       InLiner // Tool to Inline Data for the TPPI Packet
	Data        []Spec  // Collection of Specs that form the data core
	Separator   string  // Used to Separate the lines
	StartMarker string  // Use to mark the Starting of the Protocol Packet
	EndMarker   string  // used to mark the Ending of the Protocol Packet
}

// ProtocolOptions is a Function type that specifies the functional parameters
// for various TPPI protocol needs.
type ProtocolOptions func(*Protocol) (*Protocol, error)

// Default options for the Protocol
func defaultOptions() *Protocol {
	p := &Protocol{
		StartStop:   true,
		Liner:       NewLine(),
		Data:        nil,
		Separator:   SEP_CONTENT,
		StartMarker: SYM_START,
		EndMarker:   SYM_END,
	}
	return p
}

// NewProtocol helps to create the TPPI Protocol structure
func NewProtocol(op ...ProtocolOptions) (p *Protocol, err error) {
	p = defaultOptions()
	for _, o := range op {
		var tp *Protocol
		tp, err = o(p)
		if err != nil {
			err = fmt.Errorf("failed to create protocol - \n%v", err)
			return
		}
		p = tp
	}
	return
}

// WithStartStop controls the StartStop feature requirement for TPPI protocol
func WithStartStop(need bool) ProtocolOptions {
	return func(p *Protocol) (*Protocol, error) {
		p.StartStop = need
		return p, nil
	}
}

// WithInLiner sets up the InLiner needed to assemble the Specs into the
// TPPI Protocol packet
func WithInLiner(l InLiner) ProtocolOptions {
	return func(p *Protocol) (*Protocol, error) {
		p.Liner = l
		return p, nil
	}
}

// WithSymbol allows to set custom symbols for the TPPI Protocol
func WithSymbols(sep, start, end string) ProtocolOptions {
	return func(p *Protocol) (*Protocol, error) {
		p.Separator = sep
		p.StartMarker = start
		p.EndMarker = end
		return p, nil
	}
}

// With option helps to add Spec to the TPPI Protocol
func With(sa ...Spec) ProtocolOptions {
	return func(p *Protocol) (*Protocol, error) {
		return p.Add(sa...), nil
	}
}

// Add helps to build the Spec collection for the TPPI Protocol
func (p *Protocol) Add(sa ...Spec) *Protocol {
	bx := make([]Spec, 0, len(p.Data)+len(sa))
	bx = append(bx, p.Data...)
	bx = append(bx, sa...)
	p.Data = bx
	return p
}

// Build creates the TPPI Packet
func (p *Protocol) Build() (s string, err error) {
	// Perform Checks
	if len(p.Data) == 0 {
		err = fmt.Errorf("failed to build packet as no data available")
		return
	}
	if p.Liner == nil {
		err = fmt.Errorf("failed to build packet as no inliner specified")
		return
	}
	// Build the collection
	sa := make([]string, 0, len(p.Data)*2)
	for _, d := range p.Data {
		var sv []string
		var sig, value string
		// Add Signature
		sig, err = RunLiner(p.Liner, d.Sig()...)
		if err != nil {
			err = fmt.Errorf("failed to add signature due to error - %v", err)
			return
		}
		// Get the Value
		sv, err = d.Get()
		if err != nil {
			err = fmt.Errorf("failed to get value for spec due to error - %v",
				err)
			return
		}
		// Add Value
		value, err = RunLiner(p.Liner, sv...)
		if err != nil {
			err = fmt.Errorf("failed to add value due to error - %v", err)
			return
		}
		sa = append(sa, sig, value)
	}

	// Prepare the String
	s = strings.Join(sa, p.Separator)
	// Check if we need Start and End
	if p.StartStop {
		s = p.StartMarker + s + p.EndMarker
	}
	return
}
data/values.go000644 001750 001750 00000001247 14665075255 014104 0ustar00dev1729dev1729000000 000000 // Copyright (C) 2024 Abhijit Bose (aka. Boseji). All rights reserved.
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//    http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
// SPDX short identifier: Apache-2.0

package data
values/values.go000644 001750 001750 00000012134 14665232227 014461 0ustar00dev1729dev1729000000 000000 // Copyright (C) 2024 Abhijit Bose (aka. Boseji). All rights reserved.
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//    http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
// SPDX short identifier: Apache-2.0

package values

import (
	"reflect"
)

// Basic Type
type BaseType uint8

const (
	BaseInvalid BaseType = iota
	BaseBool
	BaseInt8
	BaseInt16
	BaseInt32
	BaseInt64
	BaseUint8
	BaseUint16
	BaseUint32
	BaseUint64
	BaseFloat32
	BaseFloat64
	// They do not need a Size parameter
	BaseString
	// Special type that caters to Maps, Tuples, Structures and any collections
	BaseComposed
	MaxBaseType
	MaskBaseType BaseType = 0x0F
)

// ComposedType specifies the specialty over the BaseType
type ComposedType uint8

const (
	ComposedBlankType ComposedType = iota << 4
	// ComposedArray includes both Slice and fixed ComposedArray
	// They also include a size parameter usually added to the definition.
	ComposedArray ComposedType = iota << 4
	// ComposedOverlay is an enclosed type with Values composed of other Basic types
	ComposedOverlay ComposedType = iota << 5
	// ComposedCollection is Map or Tuple like a Key-Value pair with
	// individual types specified for both the Key and value elements.
	// Structs are a type of Map with their fields as Key.
	ComposedCollection ComposedType = iota << 6
)

// describeValue helps to describe the type of the basic values
func describeValue(kind reflect.Kind, tName string, pct ComposedType) (
	bt BaseType, ct ComposedType,
) {
	ct = pct
	// Type Switch
	switch kind {
	case reflect.Bool:
		if reflect.Bool.String() != tName {
			ct += ComposedOverlay
		}
		bt = BaseBool
	case reflect.Int:
		if reflect.Int.String() != tName {
			ct += ComposedOverlay
		}
		bt = BaseInt64
	case reflect.Int8:
		if reflect.Int8.String() != tName {
			ct += ComposedOverlay
		}
		bt = BaseInt8
	case reflect.Int16:
		if reflect.Int16.String() != tName {
			ct += ComposedOverlay
		}
		bt = BaseInt16
	case reflect.Int32:
		if reflect.Int32.String() != tName {
			ct += ComposedOverlay
		}
		bt = BaseInt32
	case reflect.Int64:
		if reflect.Int64.String() != tName {
			ct += ComposedOverlay
		}
		bt = BaseInt64
	case reflect.Uint:
		if reflect.Uint.String() != tName {
			ct += ComposedOverlay
		}
		bt = BaseUint64
	case reflect.Uint8:
		if reflect.Uint8.String() != tName {
			ct += ComposedOverlay
		}
		bt = BaseUint8
	case reflect.Uint16:
		if reflect.Uint16.String() != tName {
			ct += ComposedOverlay
		}
		bt = BaseUint16
	case reflect.Uint32:
		if reflect.Uint32.String() != tName {
			ct += ComposedOverlay
		}
		bt = BaseUint32
	case reflect.Uint64:
		if reflect.Uint64.String() != tName {
			ct += ComposedOverlay
		}
		bt = BaseUint64
	case reflect.Float32:
		if reflect.Float32.String() != tName {
			ct += ComposedOverlay
		}
		bt = BaseFloat32
	case reflect.Float64:
		if reflect.Float64.String() != tName {
			ct += ComposedOverlay
		}
		bt = BaseFloat64
	default:
		return
	}
	return
}

// describeSlice helps to describe the type for Slices and Arrays
func describeSlice(val reflect.Value, pct ComposedType) (
	bt BaseType, ct ComposedType,
) {
	eVal := val.Type().Elem()
	eKind := eVal.Kind()

	// Difficult to process types
	if eKind == reflect.Chan || eKind == reflect.Func ||
		eKind == reflect.Interface || eKind == reflect.Invalid ||
		eKind == reflect.Uintptr || eKind == reflect.UnsafePointer ||
		eKind == reflect.Complex64 || eKind == reflect.Complex128 ||
		eKind == reflect.Array || eKind == reflect.Map ||
		eKind == reflect.Slice || eKind == reflect.Struct ||
		eKind == reflect.Pointer {
		return
	}

	eName := val.Type().Elem().Name()

	return describeValue(eKind, eName, ComposedArray+pct)
}

// Describe provides a way to identify the BaseType and ComposedType for any
// Data supplied.
func Describe(u any) (bt BaseType, ct ComposedType) {
	val := reflect.ValueOf(u)
	kind := val.Kind()

	// Can't process any nil values
	if kind == reflect.Pointer && val.IsNil() {
		return
	}
	// Filter out the Pointer type
	if kind == reflect.Pointer {
		kind = val.Elem().Kind()
		val = val.Elem()
	}
	// Difficult to process types
	if kind == reflect.Chan || kind == reflect.Func ||
		kind == reflect.Interface || kind == reflect.Invalid ||
		kind == reflect.Uintptr || kind == reflect.UnsafePointer ||
		kind == reflect.Complex64 || kind == reflect.Complex128 {
		return
	}
	// Type Switch
	switch kind {
	case reflect.Array:
		return describeSlice(val, ComposedBlankType)
	case reflect.Map:
		// bt = Composed
		// ct = ComposedCollection
		return
	case reflect.Slice:
		return describeSlice(val, ComposedBlankType)
	case reflect.Struct:
		// bt = Composed
		// ct = ComposedCollection
		return
	default:
		tName := val.Type().Name()
		return describeValue(kind, tName, ComposedBlankType)
	}
}
values/000755 001750 001750 00000000000 14664232013 012622 5ustar00dev1729dev1729000000 000000 old-v2/tppi.go000644 001750 001750 00000001307 14665232171 013740 0ustar00dev1729dev1729000000 000000 // Copyright (C) 2024 Abhijit Bose (aka. Boseji). All rights reserved.
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//    http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
// SPDX short identifier: Apache-2.0

// Tilde Pipe simPle Interface

package tppi
data/data_test.go000644 001750 001750 00000001247 14665061171 014545 0ustar00dev1729dev1729000000 000000 // Copyright (C) 2024 Abhijit Bose (aka. Boseji). All rights reserved.
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//    http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
// SPDX short identifier: Apache-2.0

package data
old-v2/binary.go000644 001750 001750 00000003677 14665232125 014263 0ustar00dev1729dev1729000000 000000 // Copyright (C) 2024 Abhijit Bose (aka. Boseji). All rights reserved.
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//    http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
// SPDX short identifier: Apache-2.0

package tppi

import (
	"bytes"
	"encoding/binary"
	"fmt"
	"log"

	"guthub.com/boseji/go-tppi/values"
)

// ToBinary function provides a way to convert a given datatype into its Binary
// representation.
func ToBinary(arg any, littleEndian bool, buf *bytes.Buffer) (err error) {
	bt, _ := values.Describe(arg)
	if bt == values.BaseInvalid {
		err = fmt.Errorf("unsupported type for binary conversion")
		return
	}
	// For all other data type
	if littleEndian {
		err = binary.Write(buf, binary.LittleEndian, arg)
	} else {
		err = binary.Write(buf, binary.BigEndian, arg)
	}
	if err != nil {
		err = fmt.Errorf("failed to convert to binary : %v", err)
	}
	return
}

// FromBinary function provides a way to Binary data back into the the
// respective Datatype representation.
// In case of Slices pass a Preallocated size with make(type,length) pointer.
func FromBinary(arg any, buf *bytes.Buffer, littleEndian bool) (err error) {
	bt, _ := values.Describe(arg)
	if bt == values.BaseInvalid {
		err = fmt.Errorf("unsupported type for binary recovery")
		return
	}
	if littleEndian {
		err = binary.Read(buf, binary.LittleEndian, arg)
	} else {
		err = binary.Read(buf, binary.BigEndian, arg)
	}
	if err != nil {
		err = fmt.Errorf("failed to convert back from binary : %v", err)
	}
	log.Printf("%#+v", arg)
	return
}
data/data.go000644 001750 001750 00000002633 14665060666 013516 0ustar00dev1729dev1729000000 000000 // Copyright (C) 2024 Abhijit Bose (aka. Boseji). All rights reserved.
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//    http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
// SPDX short identifier: Apache-2.0

// data Package
//
// This is a complementary package to the TPPI protocol.
// Here we helps to prepare the data into its string representations and
// recover the data back for use.
//
// There are several helpful methods detailed here that are designed to
// provide a basis for build higher abstractions to support making the
// TPPI content and use TPPI protocol.
package data

// Represent Interface provides a way to support the TPPI content needs.
type Represent interface {
	// Type provides a TypeSignature needed to identify the Data enclosed
	Type() string
	// String provides the string representation of the Data to be used
	String() string
	// Recover provides a way to restore the Data back from its string form.
	Recover(string, string, string) error
}
old-v1/symbol.go000644 001750 001750 00000010653 14665231770 014300 0ustar00dev1729dev1729000000 000000 // Copyright (C) 2024 Abhijit Bose (aka. Boseji). All rights reserved.
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//    http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
// SPDX short identifier: Apache-2.0

package tppi

import (
	"fmt"
	"regexp"
	"strings"
)

// Protocol Level Symbol Constants
const (
	SYM_TILDE = "~"
	SYM_PIPE  = "|"
	SYM_START = "~|"
	SYM_END   = "|~"
)

// Protocol Separators
const (
	SEP_CONTENT = SYM_TILDE
	SEP_LINES   = SYM_PIPE
)

// Protocol Regex Filters
const (
	regexp_STUFF_PIPE     = `(?m)[\|]`
	regexp_STUFF_TILDE    = `(?m)[~]`
	replace_STUFF_PIPE    = `\x7C`
	replace_STUFF_TILDE   = `\x2D`
	regexp_UN_STUFF_PIPE  = `(?m)(\\x7C)`
	regexp_UN_STUFF_TILDE = `(?m)(\\x2D)`
	regexp_Stuffed        = `(?m)[\|~]`
)

// Stuff implements the Rules method to adds necessary
// protocol detection guards on a supplied content for TPPI protocol.
func Stuff(s string) (sv string, err error) {
	if len(s) == 0 {
		err = fmt.Errorf("no supplied parts to stuff")
		return
	}
	sv = strings.Clone(s)
	// Pipe Regex
	re := regexp.MustCompile(regexp_STUFF_PIPE)
	sv = re.ReplaceAllString(sv, replace_STUFF_PIPE)
	// Tilde Regex
	re = regexp.MustCompile(regexp_STUFF_TILDE)
	sv = re.ReplaceAllString(sv, replace_STUFF_TILDE)
	return
}

// UnStuff implements the Rules method to remove the protocol detection guards
// on the supplied content for TPPI protocol.
func UnStuff(s string) (sv string, err error) {
	if len(s) == 0 {
		err = fmt.Errorf("no supplied parts to un-stuff")
		return
	}
	sv = strings.Clone(s)
	// Pipe Regex
	re := regexp.MustCompile(regexp_UN_STUFF_PIPE)
	sv = re.ReplaceAllString(sv, SYM_PIPE)
	// Tilde Regex
	re = regexp.MustCompile(regexp_UN_STUFF_TILDE)
	sv = re.ReplaceAllString(sv, SYM_TILDE)
	return
}

// NeedsStuff reports if the supplied string contains Symbols that needs
// stuffing as per TPPI protocol.
// Returns True only if the has Symbols that needs stuffing.
func NeedsStuff(s string) bool {
	re := regexp.MustCompile(regexp_Stuffed)
	sa := re.FindAllString(s, -1)
	return (len(sa) > 0)
}

// JoinLines implements the CollectionRule method to help
// join multiple Lines together for TPPI protocol.
func JoinLines(sa ...string) (s string, err error) {
	if len(sa) == 0 {
		err = fmt.Errorf("no supplied parts to join lines")
		return
	}
	s = strings.Join(sa, SEP_LINES)
	return
}

// JoinContents implements the CollectionRule method to help join the contents
// into a single line for TPPI protocol.
func JoinContents(sa ...string) (s string, err error) {
	if len(sa) == 0 {
		err = fmt.Errorf("no supplied parts to join content")
		return
	}
	s = strings.Join(sa, SEP_CONTENT)
	return
}

// SplitLines implements the SplittingRule method to help break the provided
// packet into multiple lines for TPPI protocol.
func SplitLines(s string) (sa []string, err error) {
	if len(s) == 0 {
		err = fmt.Errorf("no string supplied to split into lines")
		return
	}
	sa = strings.Split(s, SEP_LINES)
	return
}

// SplitContents implements tge SplittingRule method to help break the
// provided line into its contents for TPPI protocol.
func SplitContents(s string) (sa []string, err error) {
	if len(s) == 0 {
		err = fmt.Errorf("no string supplied to split into content")
		return
	}
	sa = strings.Split(s, SEP_CONTENT)
	return
}

// AddStartEnd implements the Rules method that helps to add the framing
// for the protocol packet for TPPI protocol.
func AddStartEnd(s string) (sv string, err error) {
	if len(s) == 0 {
		err = fmt.Errorf("no string supplied to add start and end")
		return
	}
	sv = SYM_START + s + SYM_END
	return
}

// RemoveStartEnd implements the Rules method that helps to remove the framing
// for the protocol packet for TPPI protocol.
func RemoveStartEnd(s string) (sv string, err error) {
	if len(s) == 0 {
		err = fmt.Errorf("no string supplied to remove start and end")
		return
	}
	sv = strings.Clone(s)
	if strings.Contains(sv, SYM_START) {
		sv = strings.ReplaceAll(s, SYM_START, "")
	}
	if strings.Contains(sv, SYM_END) {
		sv = strings.ReplaceAll(sv, SYM_END, "")
	}
	return
}
data/values_byteslice_test.go000644 001750 001750 00000006713 14665106451 017202 0ustar00dev1729dev1729000000 000000 // Copyright (C) 2024 Abhijit Bose (aka. Boseji). All rights reserved.
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//    http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
// SPDX short identifier: Apache-2.0

package data

import (
	"reflect"
	"strings"
	"testing"
)

func Test_ByteSlice(t *testing.T) {
	tests := []struct {
		name  string
		value ByteSlice
		wantS string
		wantT string
	}{
		{
			name:  "ByteSlice representation1",
			value: NewByteSlice([]byte{1, 2, 3}),
			wantS: "[1 2 3]",
			wantT: byteSliceTypeSignature,
		},
		{
			name:  "Int representation2",
			value: NewByteSlice([]byte{}),
			wantS: "[]",
			wantT: byteSliceTypeSignature,
		},
		{
			name:  "Int representation3",
			value: NewByteSlice(nil),
			wantS: "[]",
			wantT: byteSliceTypeSignature,
		},
		{
			name:  "ByteSlice representation1",
			value: NewByteSlice([]byte{0x3A, 0xF1, 0x41}),
			wantS: "[3a f1 41]",
			wantT: byteSliceTypeSignature,
		},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			gotS := tt.value.String()
			gotT := tt.value.Type()
			if strings.Compare(gotS, tt.wantS) != 0 {
				t.Errorf("error in String got %v expected %v", gotS, tt.wantS)
				return
			}
			if strings.Compare(gotT, tt.wantT) != 0 {
				t.Errorf("error in Type got %v expected %v", gotT, tt.wantT)
			}
		})
	}
	tests2 := []struct {
		name    string
		argType string
		argTag  string
		argData string
		want    ByteSlice
		wantErr bool
	}{
		{
			name:    "ByteSlice recovery1",
			argType: byteSliceTypeSignature,
			argTag:  "",
			argData: "[1 2 3]",
			want:    NewByteSlice([]byte{1, 2, 3}),
		},
		{
			name:    "ByteSlice recovery2",
			argType: byteSliceTypeSignature,
			argTag:  "temp",
			argData: "[]",
			want:    NewByteSlice([]byte{}).SetTag("temp"),
		},
		{
			name:    "ByteSlice recovery3",
			argType: byteSliceTypeSignature,
			argTag:  "ID",
			argData: "[3a f1 41]",
			want:    NewByteSlice([]byte{0x3A, 0xF1, 0x41}).SetTag("ID"),
		},
		{
			name:    "ByteSlice recovery Error1",
			argType: "k",
			argTag:  "",
			argData: "[1 2 3]",
			wantErr: true,
		},
		{
			name:    "ByteSlice recovery Error2",
			argType: byteSliceTypeSignature,
			argTag:  "",
			argData: "[",
			wantErr: true,
		},
		{
			name:    "ByteSlice recovery Error3",
			argType: byteSliceTypeSignature,
			argTag:  "",
			argData: "[-3 3]",
			wantErr: true,
		},
		{
			name:    "ByteSlice recovery Error4",
			argType: byteSliceTypeSignature,
			argTag:  "",
			argData: "[ 3 3]",
			wantErr: true,
		},
		{
			name:    "ByteSlice recovery Error5",
			argType: byteSliceTypeSignature,
			argTag:  "",
			argData: "[3 3 fff]",
			wantErr: true,
		},
	}
	for _, tt := range tests2 {
		t.Run(tt.name, func(t *testing.T) {
			b := NewByteSlice([]byte{})
			err := b.Recover(tt.argType, tt.argTag, tt.argData)
			if (err != nil) != tt.wantErr {
				t.Errorf("failed to Recover() error - %v want error %v",
					err, tt.wantErr)
				return
			}
			if !tt.wantErr && !reflect.DeepEqual(b, tt.want) {
				t.Errorf("value error got %#v expected %#v", b, tt.want)
			}
		})
	}
}
old-v1/line_inliner.go000644 001750 001750 00000011106 14665231674 015437 0ustar00dev1729dev1729000000 000000 // Copyright (C) 2024 Abhijit Bose (aka. Boseji). All rights reserved.
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//    http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
// SPDX short identifier: Apache-2.0

package tppi

import (
	"fmt"
)

// Line type generates the Line Needed for the protocol with the necessary
// TPPI protocol safeguards.
type Line struct {
	parts           []string         // Raw contents
	joinRule        CollectionRule   // Rule to Create the Final line
	splitRule       SplittingRule    // Rule to Split and obtain contents
	stuffingRules   map[string]Rules // Stuffing Rules for the contents
	unStuffingRules map[string]Rules // UnStuffing Rules for the contents
}

// LineOptions helps to setup parameters for the Line for TPPI Protocol
type LineOptions func(*Line) *Line

// Add allows to add more contents to the Line following the
// protocol safeguards of TPPI Protocol.
// It implements the InLiner interface.
func (l *Line) Add(sa ...string) error {
	safe := make([]string, 0, len(l.parts)+len(sa))
	safe = append(safe, l.parts...)
	safe = append(safe, sa...)
	l.parts = safe
	return nil
}

// Contents returns the contents of the given line as a []string slice.
// It implements the InLiner interface.
func (l *Line) Contents() []string {
	return l.parts
}

// Process creates the formatted single line following the assembly
// as per the rules of TPPI Protocol.
// It implements the InLiner interface.
func (l *Line) Processed() (s string, err error) {
	if len(l.parts) == 0 {
		err = fmt.Errorf("unable to process as no contents in line")
		return
	}
	sa, err := RunRules(l.stuffingRules, l.parts...)
	if err != nil {
		err = fmt.Errorf("unable to process as stuffing rules failed - %v", err)
		return
	}
	// Join everything with Inline separator
	s, err = l.joinRule(sa...)
	if err != nil {
		err = fmt.Errorf("unable to process as joining rule failed - %v", err)
		return
	}
	return
}

// Decode Creates a collection contents based on the supplied combined string
// following the rules of TPPI Protocol.
// It implements the InLiner interface.
func (b *Line) Decode(s string) (err error) {
	sa, err := b.splitRule(s)
	if err != nil {
		err = fmt.Errorf("unable to decode as splitting rule failed - %v", err)
		return
	}
	sf, err := RunRules(b.unStuffingRules, sa...)
	if err != nil {
		err = fmt.Errorf("unable to decode as un-Stuffing rules failed - %v",
			err)
		return
	}
	b.parts = sf
	return
}

// Clear helps to clean up the line contents and prepare a fresh InLiner.
// It implements the InLiner interface.
func (b *Line) Clear() {
	b.parts = make([]string, 0, 1)
}

// WithLineJoin helps to add a CollectionRule for the Line to prepare
// a line with all the contents as per TPPI protocol.
func WithLineJoin(j CollectionRule) LineOptions {
	return func(l *Line) *Line {
		l.joinRule = j
		return l
	}
}

// WithLineSplit helps to add a SplittingRule for the Line to
// decode a line into a collection of contents as per TPPI protocol.
func WithLineSplit(s SplittingRule) LineOptions {
	return func(l *Line) *Line {
		l.splitRule = s
		return l
	}
}

// WithLineStuffing helps to add a named Stuffing rule for the Line to
// filter contents of the line as per TPPI protocol safe guards.
func WithLineStuffing(name string, f Rules) LineOptions {
	return func(l *Line) *Line {
		l.stuffingRules[name] = f
		return l
	}
}

// WithLineUnStuffing helps to add a named UnStuffing rule for the Line to
// restore the contents removing the TPPI protocol safe guards.
func WithLineUnStuffing(name string, f Rules) LineOptions {
	return func(l *Line) *Line {
		l.unStuffingRules[name] = f
		return l
	}
}

// defaultLine sets up the Line with default options for the TPPI protocol
func defaultLine() *Line {
	l := &Line{
		parts:     make([]string, 0, 1),
		joinRule:  JoinContents,
		splitRule: SplitContents,
		stuffingRules: map[string]Rules{
			"Stuffing": Stuff,
		},
		unStuffingRules: map[string]Rules{
			"UnStuffing": UnStuff,
		},
	}
	return l
}

// NewLine creates the new instance of the Line with InLiner interface
// signature and Line specific options
func NewLine(op ...LineOptions) InLiner {
	l := defaultLine()
	for _, o := range op {
		l = o(l)
	}
	return l
}