Some helper functions

Author: Maksim Naumov

Diff for: php_serialize/common_helper.go

@@ -0,0 +1,100 @@
+package php_serialize
+
+import (
+	"strconv"
+)
+
+func PhpValueString(p PhpValue) (res string) {
+	res, _ = p.(string)
+	return
+}
+
+func PhpValueBool(p PhpValue) (res bool) {
+	switch p.(type) {
+	case bool:
+		res, _ = p.(bool)
+	case string:
+		str, _ := p.(string)
+		res, _ = strconv.ParseBool(str)
+	}
+	return
+}
+
+func PhpValueInt(p PhpValue) (res int) {
+	switch p.(type) {
+	case int:
+		res, _ = p.(int)
+	case int8:
+		intVal, _ := p.(int8)
+		res = int(intVal)
+	case int16:
+		intVal, _ := p.(int16)
+		res = int(intVal)
+	case int32:
+		intVal, _ := p.(int32)
+		res = int(intVal)
+	case int64:
+		intVal, _ := p.(int64)
+		res = int(intVal)
+	case uint:
+		intVal, _ := p.(uint)
+		res = int(intVal)
+	case uint8:
+		intVal, _ := p.(uint8)
+		res = int(intVal)
+	case uint16:
+		intVal, _ := p.(uint16)
+		res = int(intVal)
+	case uint32:
+		intVal, _ := p.(uint32)
+		res = int(intVal)
+	case uint64:
+		intVal, _ := p.(uint64)
+		res = int(intVal)
+	case string:
+		str, _ := p.(string)
+		res, _ = strconv.Atoi(str)
+	}
+	return
+}
+
+func PhpValueInt64(p PhpValue) (res int64) {
+	switch p.(type) {
+	case int64:
+		res = p.(int64)
+	default:
+		res = int64(PhpValueInt(p))
+	}
+	return
+}
+
+func PhpValueUInt(p PhpValue) (res uint) {
+	switch p.(type) {
+	case uint:
+		res = p.(uint)
+	default:
+		res = uint(PhpValueInt(p))
+	}
+	return
+}
+
+func PhpValueUInt64(p PhpValue) (res uint64) {
+	switch p.(type) {
+	case uint64:
+		res = p.(uint64)
+	default:
+		res = uint64(PhpValueInt(p))
+	}
+	return
+}
+
+func PhpValueFloat64(p PhpValue) (res float64) {
+	switch p.(type) {
+	case float64:
+		res, _ = p.(float64)
+	case string:
+		str, _ := p.(string)
+		res, _ = strconv.ParseFloat(str, 64)
+	}
+	return
+}

Diff for: php_serialize/common_helper_test.go

@@ -0,0 +1,73 @@
+package php_serialize
+
+import "testing"
+
+func TestPhpValueString(t *testing.T) {
+	var (
+		val PhpValue = "string"
+		expected string = "string"
+	)
+	if newVal := PhpValueString(val); newVal != expected {
+		t.Errorf("Expected %q but got %q", expected, newVal)
+	}
+}
+
+func TestPhpValueBool(t *testing.T) {
+	var (
+		val PhpValue = true
+		expected bool = true
+	)
+	if newVal := PhpValueBool(val); newVal != expected {
+		t.Errorf("Expected %t but got %t", expected, newVal)
+	}
+}
+
+func TestPhpValueInt(t *testing.T) {
+	var (
+		val PhpValue = 10
+		expected int = 10
+	)
+	if newVal := PhpValueInt(val); newVal != expected {
+		t.Errorf("Expected %d but got %d", expected, newVal)
+	}
+}
+
+func TestPhpValueInt64(t *testing.T) {
+	var (
+		val PhpValue = int64(10)
+		expected int64 = 10
+	)
+	if newVal := PhpValueInt64(val); newVal != expected {
+		t.Errorf("Expected %d but got %d", expected, newVal)
+	}
+}
+
+func TestPhpValueUInt(t *testing.T) {
+	var (
+		val PhpValue = uint(10)
+		expected uint = 10
+	)
+	if newVal := PhpValueUInt(val); newVal != expected {
+		t.Errorf("Expected %d but got %d", expected, newVal)
+	}
+}
+
+func TestPhpValueUInt64(t *testing.T) {
+	var (
+		val PhpValue = uint64(10)
+		expected uint64 = 10
+	)
+	if newVal := PhpValueUInt64(val); newVal != expected {
+		t.Errorf("Expected %d but got %d", expected, newVal)
+	}
+}
+
+func TestPhpValueFloat64(t *testing.T) {
+	var (
+		val PhpValue = float64(10.0)
+		expected float64 = 10.0
+	)
+	if newVal := PhpValueFloat64(val); newVal != expected {
+		t.Errorf("Expected %v but got %v", expected, newVal)
+	}
+}