fixed DecodeSchema() logic for custom types

Author: BenjaminPritchard

date.go

@@ -1,7 +1,6 @@
 package schemer
 
 import (
-	"bufio"
 	"encoding/json"
 	"fmt"
 	"io"
@@ -11,7 +10,7 @@ import (
 )
 
 // each custom type has a unique name an a unique UUID
-const dateSchemaUUID byte = 1 // each custom type has a unique id
+const dateSchemaUUID byte = 1
 
 type DateSchema struct {
 	SchemaOptions
@@ -39,16 +38,16 @@ func (sg dateSchemaGenerator) SchemaOfType(t reflect.Type) (Schema, error) {
 	return nil, nil
 }
 
-func (sg dateSchemaGenerator) DecodeSchema(br *bufio.Reader) (Schema, error) {
+func (sg dateSchemaGenerator) DecodeSchema(r io.Reader) (Schema, error) {
 
-	tmpBuf, err := br.Peek(2)
+	tmpBuf := make([]byte, 1)
+	_, err := r.Read(tmpBuf)
 	if err != nil {
 		return nil, err
 	}
 
-	if tmpBuf[0] == CustomSchemaMask {
-		// don't advance byte index if we don't have a date schema
-		if tmpBuf[1] != dateSchemaUUID {
+	if tmpBuf[0]&CustomSchemaMask == CustomSchemaMask {
+		if tmpBuf[0]&(dateSchemaUUID<<4) != (dateSchemaUUID << 4) {
 			return nil, nil
 		}
 	} else {
@@ -60,6 +59,7 @@ func (sg dateSchemaGenerator) DecodeSchema(br *bufio.Reader) (Schema, error) {
 	s := DateSchema{}
 	s.SetNullable(nullable)
 	return &s, nil
+
 }
 
 func (sg dateSchemaGenerator) DecodeSchemaJSON(r io.Reader) (Schema, error) {
@@ -125,20 +125,19 @@ func (s *DateSchema) MarshalJSON() ([]byte, error) {
 // Bytes encodes the schema in a portable binary format
 func (s *DateSchema) MarshalSchemer() ([]byte, error) {
 
-	const schemerDateSize byte = 1 + 1 // 1 byte for the schema + 1 bytes for the UUID
+	const schemerDateSize byte = 1
 
 	// string schemas are 1 byte long
 	var schema []byte = make([]byte, schemerDateSize)
 
-	schema[0] = CustomSchemaMask
+	schema[0] |= CustomSchemaMask
+	schema[0] |= (dateSchemaUUID<<4)
 
 	// The most signifiant bit indicates whether or not the type is nullable
 	if s.Nullable() {
 		schema[0] |= 0x80
 	}
 
-	schema[1] = dateSchemaUUID
-
 	return schema, nil
 }
 

date_test.go

@@ -1,6 +1,10 @@
 package schemer
 
-/*
+import (
+	"bytes"
+	"testing"
+	"time"
+)
 
 // uses a time.Time directly...
 func testRegisteredType1(useJSON bool, t *testing.T) {
@@ -179,4 +183,4 @@ func TestCustomDates(t *testing.T) {
 	testRegisteredType2(false, t)
 }
 
-*/
+// 0x 29 06 02 09 49 6e 74 46 69 65 6c 64 31 11 02 04 44 61 74 65 3f01020353747220

ipv4.go

@@ -10,8 +10,7 @@ import (
 )
 
 // each custom type has a unique name an a unique UUID
-//const ipV4SchemaName string = "ipv4"
-const ipV4SchemaUUID byte = 02
+const ipV4SchemaUUID byte = 2
 
 type ipv4Schema struct {
 	SchemaOptions
@@ -41,29 +40,25 @@ func (sg ipv4SchemaGenerator) SchemaOfType(t reflect.Type) (Schema, error) {
 
 func (sg ipv4SchemaGenerator) DecodeSchema(r io.Reader) (Schema, error) {
 
-	return nil, nil
-
-	/*
+	tmpBuf := make([]byte, 1)
+	_, err := r.Read(tmpBuf)
+	if err != nil {
+		return nil, err
+	}
 
-		if buf[*byteIndex] == CustomSchemaMask {
-			// don't advance byte index if we don't have an IPv4 schema
-			if buf[*byteIndex+1] != ipV4SchemaUUID {
-				return nil, nil
-			}
-		} else {
+	if tmpBuf[0]&CustomSchemaMask == CustomSchemaMask {
+		if tmpBuf[0]&(ipV4SchemaUUID<<4) != (ipV4SchemaUUID << 4) {
 			return nil, nil
 		}
+	} else {
+		return nil, nil
+	}
 
-		nullable := (buf[*byteIndex]&SchemaNullBit == SchemaNullBit)
-
-		// advance past customSchemaMask and UUID
-		*byteIndex++
-		*byteIndex++
+	nullable := (tmpBuf[0]&SchemaNullBit == SchemaNullBit)
 
-		s := ipv4Schema{}
-		s.SetNullable(nullable)
-		return &s, nil
-	*/
+	s := ipv4Schema{}
+	s.SetNullable(nullable)
+	return &s, nil
 
 }
 
@@ -138,20 +133,19 @@ func (s *ipv4Schema) MarshalJSON() ([]byte, error) {
 // Bytes encodes the schema in a portable binary format
 func (s *ipv4Schema) MarshalSchemer() ([]byte, error) {
 
-	const schemerDateSize byte = 1 + 1 // 1 byte for the schema + 1 bytes for the UUID
+	const schemerDateSize byte = 1
 
 	// string schemas are 1 byte long
 	var schema []byte = make([]byte, schemerDateSize)
 
-	schema[0] = CustomSchemaMask
+	schema[0] |= CustomSchemaMask
+	schema[0] |= (ipV4SchemaUUID << 4)
 
 	// The most signifiant bit indicates whether or not the type is nullable
 	if s.Nullable() {
 		schema[0] |= 0x80
 	}
 
-	schema[1] = ipV4SchemaUUID
-
 	return schema, nil
 }
 

ipv4_test.go

@@ -1,6 +1,10 @@
 package schemer
 
-/*
+import (
+	"bytes"
+	"net"
+	"testing"
+)
 
 // uses a net.IP  directly...
 func testIPv41(useJSON bool, t *testing.T) {
@@ -171,5 +175,3 @@ func TestIPv41(t *testing.T) {
 	testIPv42(true, t)
 	testIPv42(false, t)
 }
-
-*/

schemer.go

@@ -1,7 +1,12 @@
 package schemer
 
+// TODO:
+//		-> type TypeByte byte
+//	-	-> model decode after decodeJSON
+//	-	-> squeze custom type into 6 bits , based on reserved type (CustomSchemaMask to be 0x40)
+//
+
 import (
-	"bufio"
 	"bytes"
 	"encoding/json"
 	"fmt"
@@ -26,7 +31,7 @@ const (
 	VarArraySchemaMask      = 0x24
 	FixedObjectSchemaMask   = 0x29 // 0b10 100f 	where f indicates that the object has fixed number of fields
 	VarObjectSchemaMask     = 0x28
-	CustomSchemaMask        = 0x3F // 0b11 1111
+	CustomSchemaMask        = 0x40 // bit 7 indicates custom schema type
 	SchemaNullBit           = 0x80 // The most signifiant bit indicates whether or not the type is nullable
 )
 
@@ -69,7 +74,7 @@ type Marshaler interface {
 // then the built-in logic for returning a Schema is used.
 type SchemaGenerator interface {
 	SchemaOfType(t reflect.Type) (Schema, error)
-	DecodeSchema(b *bufio.Reader) (Schema, error)
+	DecodeSchema(r io.Reader) (Schema, error)
 	DecodeSchemaJSON(r io.Reader) (Schema, error)
 }
 
@@ -612,15 +617,11 @@ func DecodeSchemaJSON(r io.Reader) (Schema, error) {
 	return nil, fmt.Errorf("invalid schema type: %s", typeStr)
 }
 
-func DecodeSchema(r io.Reader) (Schema, error) {
-	br := bufio.NewReader(r)
-	return decodeSchema(br)
-}
-
 // decodeSchema processes buf[] to actually decode the binary schema.
 // As each byte is processed, this routine advances *byteIndex, which indicates
 // how far into the buffer we have processed already.
-func decodeSchema(r io.Reader) (Schema, error) {
+func DecodeSchema(r io.Reader) (Schema, error) {
+
 	const (
 		TwoBitSchemaMask  = 0x30
 		FourBitSchemaMask = 0x3C
@@ -630,21 +631,19 @@ func decodeSchema(r io.Reader) (Schema, error) {
 
 	var err error
 
-	// Call registered schema generators
-
-	/*
-		for _, sg := range regDecodeSchema {
-			if s, err := sg.DecodeSchema(r); s != nil || err != nil {
-				return s, err
-			}
-		}
-	*/
-
 	buf := make([]byte, 1)
 	_, err = r.Read(buf)
 	if err != nil {
 		return nil, err
 	}
+
+	// Call registered schema generators
+	for _, sg := range regDecodeSchema {
+		if s, err := sg.DecodeSchema(bytes.NewReader(buf)); s != nil || err != nil {
+			return s, err
+		}
+	}
+
 	curByte := buf[0]
 
 	// decode fixed int schema
@@ -763,7 +762,7 @@ func decodeSchema(r io.Reader) (Schema, error) {
 			return nil, err
 		}
 
-		FixedArraySchema.Element, err = decodeSchema(r)
+		FixedArraySchema.Element, err = DecodeSchema(r)
 		if err != nil {
 			return nil, err
 		}
@@ -777,7 +776,7 @@ func decodeSchema(r io.Reader) (Schema, error) {
 
 		varArraySchema.SchemaOptions.nullable = (curByte&SchemaNullBit == SchemaNullBit)
 
-		varArraySchema.Element, err = decodeSchema(r)
+		varArraySchema.Element, err = DecodeSchema(r)
 		if err != nil {
 			return nil, err
 		}
@@ -818,8 +817,7 @@ func decodeSchema(r io.Reader) (Schema, error) {
 
 			}
 
-			// decodeSchema recursive call will advance *byteIndex for each field...
-			of.Schema, err = decodeSchema(r)
+			of.Schema, err = DecodeSchema(r)
 			if err != nil {
 				return nil, err
 			}
@@ -836,12 +834,12 @@ func decodeSchema(r io.Reader) (Schema, error) {
 
 		varObjectSchema.SchemaOptions.nullable = (curByte&SchemaNullBit == SchemaNullBit)
 
-		varObjectSchema.Key, err = decodeSchema(r)
+		varObjectSchema.Key, err = DecodeSchema(r)
 		if err != nil {
 			return nil, err
 		}
 
-		varObjectSchema.Value, err = decodeSchema(r)
+		varObjectSchema.Value, err = DecodeSchema(r)
 		if err != nil {
 			return nil, err
 		}
@@ -948,5 +946,5 @@ func PreDecode(nullable bool, r io.Reader, v reflect.Value) (reflect.Value, erro
 // initialization function for the Schemer Library
 func init() {
 	Register(dateSchemaGenerator{})
-	//Register(ipv4SchemaGenerator{})
+	Register(ipv4SchemaGenerator{})
 }