Skip to content

Commit

Permalink
refactored the way we get empty interfaces of *TypeInfo and renamed t…
Browse files Browse the repository at this point in the history 
…he function (*TypeInfo)New()
  • Loading branch information
@cwndrws
cwndrws committed Feb 6, 2014
1 parent bf7c0bc commit 355de42
Show file tree
Hide file tree
Showing 2 changed files with 21 additions and 334 deletions.
Binary file added .helpers.go.swp
View file
Binary file not shown.
355 changes: 21 additions & 334 deletions helpers.go
View file
Original file line number Diff line number Diff line change
@@ -1,354 +1,41 @@
package gocql

func ptrOfType(t *TypeInfo) interface{} {
import "reflect"

func (t *TypeInfo) New() interface{} {
return reflect.New(goType(t)).Interface()
}

func goType(t *TypeInfo) reflect.Type {
switch t.Type {
case TypeVarchar, TypeAscii:
return new(string)
return reflect.TypeOf(*new(string))
case TypeBigInt, TypeCounter, TypeTimestamp:
return new(int64)
return reflect.TypeOf(*new(int64))
case TypeBlob:
return new([]byte)
return reflect.TypeOf(*new([]byte))
case TypeBoolean:
return new(bool)
return reflect.TypeOf(*new(bool))
case TypeFloat:
return new(float32)
return reflect.TypeOf(*new(float32))
case TypeDouble:
return new(float64)
return reflect.TypeOf(*new(float64))
case TypeInt:
return new(int32)
return reflect.TypeOf(*new(int32))
case TypeUUID, TypeTimeUUID:
return new(UUID)
return reflect.TypeOf(*new(UUID))
case TypeList, TypeSet:
switch t.Elem.Type {
case TypeVarchar, TypeAscii:
return new([]string)
case TypeBigInt, TypeCounter, TypeTimestamp:
return new([]int64)
case TypeBlob:
return new([][]byte)
case TypeBoolean:
return new([]bool)
case TypeFloat:
return new([]float32)
case TypeDouble:
return new([]float64)
case TypeInt:
return new([]int32)
case TypeUUID, TypeTimeUUID:
return new([]UUID)
}
return new([][]byte)

return reflect.SliceOf(goType(t.Elem))
case TypeMap:
switch t.Key.Type {
case TypeVarchar, TypeAscii:
switch t.Elem.Type {
case TypeVarchar, TypeAscii:
return new(map[string]string)
case TypeBigInt, TypeCounter, TypeTimestamp:
return new(map[string]int64)
case TypeBlob:
return new(map[string][]byte)
case TypeBoolean:
return new(map[string]bool)
case TypeFloat:
return new(map[string]float32)
case TypeDouble:
return new(map[string]float64)
case TypeInt:
return new(map[string]int32)
case TypeUUID, TypeTimeUUID:
return new(map[string]UUID)
}
case TypeBigInt, TypeCounter, TypeTimestamp:
switch t.Elem.Type {
case TypeVarchar, TypeAscii:
return new(map[int64]string)
case TypeBigInt, TypeCounter, TypeTimestamp:
return new(map[int64]int64)
case TypeBlob:
return new(map[int64][]byte)
case TypeBoolean:
return new(map[int64]bool)
case TypeFloat:
return new(map[int64]float32)
case TypeDouble:
return new(map[int64]float64)
case TypeInt:
return new(map[int64]int32)
case TypeUUID, TypeTimeUUID:
return new(map[int64]UUID)
}
case TypeBlob:
switch t.Elem.Type {
case TypeVarchar, TypeAscii:
return new(map[string]string)
case TypeBigInt, TypeCounter, TypeTimestamp:
return new(map[string]int64)
case TypeBlob:
return new(map[string][]byte)
case TypeBoolean:
return new(map[string]bool)
case TypeFloat:
return new(map[string]float32)
case TypeDouble:
return new(map[string]float64)
case TypeInt:
return new(map[string]int32)
case TypeUUID, TypeTimeUUID:
return new(map[string]UUID)
}
case TypeBoolean:
switch t.Elem.Type {
case TypeVarchar, TypeAscii:
return new(map[bool]string)
case TypeBigInt, TypeCounter, TypeTimestamp:
return new(map[bool]int64)
case TypeBlob:
return new(map[bool][]byte)
case TypeBoolean:
return new(map[bool]bool)
case TypeFloat:
return new(map[bool]float32)
case TypeDouble:
return new(map[bool]float64)
case TypeInt:
return new(map[bool]int32)
case TypeUUID, TypeTimeUUID:
return new(map[bool]UUID)
}
case TypeFloat:
switch t.Elem.Type {
case TypeVarchar, TypeAscii:
return new(map[float32]string)
case TypeBigInt, TypeCounter, TypeTimestamp:
return new(map[float32]int64)
case TypeBlob:
return new(map[float32][]byte)
case TypeBoolean:
return new(map[float32]bool)
case TypeFloat:
return new(map[float32]float32)
case TypeDouble:
return new(map[float32]float64)
case TypeInt:
return new(map[float32]int32)
case TypeUUID, TypeTimeUUID:
return new(map[float32]UUID)
}
case TypeDouble:
switch t.Elem.Type {
case TypeVarchar, TypeAscii:
return new(map[float64]string)
case TypeBigInt, TypeCounter, TypeTimestamp:
return new(map[float64]int64)
case TypeBlob:
return new(map[float64][]byte)
case TypeBoolean:
return new(map[float64]bool)
case TypeFloat:
return new(map[float64]float32)
case TypeDouble:
return new(map[float64]float64)
case TypeInt:
return new(map[float64]int32)
case TypeUUID, TypeTimeUUID:
return new(map[float64]UUID)
}
case TypeInt:
switch t.Elem.Type {
case TypeVarchar, TypeAscii:
return new(map[int32]string)
case TypeBigInt, TypeCounter, TypeTimestamp:
return new(map[int32]int64)
case TypeBlob:
return new(map[int32][]byte)
case TypeBoolean:
return new(map[int32]bool)
case TypeFloat:
return new(map[int32]float32)
case TypeDouble:
return new(map[int32]float64)
case TypeInt:
return new(map[int32]int32)
case TypeUUID, TypeTimeUUID:
return new(map[int32]UUID)
}
case TypeUUID, TypeTimeUUID:
switch t.Elem.Type {
case TypeVarchar, TypeAscii:
return new(map[UUID]string)
case TypeBigInt, TypeCounter, TypeTimestamp:
return new(map[UUID]int64)
case TypeBlob:
return new(map[UUID][]byte)
case TypeBoolean:
return new(map[UUID]bool)
case TypeFloat:
return new(map[UUID]float32)
case TypeDouble:
return new(map[UUID]float64)
case TypeInt:
return new(map[UUID]int32)
case TypeUUID, TypeTimeUUID:
return new(map[UUID]UUID)
}
}
return reflect.MapOf(goType(t.Key), goType(t.Elem))
default:
return new([]byte)
return nil
}
return new(map[string]string)
}

func dereference(i interface{}) interface{} {
switch i.(type) {
case *string:
return *i.(*string)
case *int64:
return *i.(*int64)
case *[]byte:
return *i.(*[]byte)
case *bool:
return *i.(*bool)
case *float32:
return *i.(*float32)
case *float64:
return *i.(*float64)
case *int32:
return *i.(*int32)
case *UUID:
return *i.(*UUID)
case *[]string:
return *i.(*[]string)
case *[]int64:
return *i.(*[]int64)
case *[][]byte:
return *i.(*[][]byte)
case *[]bool:
return *i.(*[]bool)
case *[]float32:
return *i.(*[]float32)
case *[]float64:
return *i.(*[]float64)
case *[]int32:
return *i.(*[]int32)
case *[]UUID:
return *i.(*[]UUID)
case *map[string]string:
return *i.(*map[string]string)
case *map[string]int64:
return *i.(*map[string]int64)
case *map[string][]byte:
return *i.(*map[string][]byte)
case *map[string]bool:
return *i.(*map[string]bool)
case *map[string]float32:
return *i.(*map[string]float32)
case *map[string]float64:
return *i.(*map[string]float64)
case *map[string]int32:
return *i.(*map[string]int32)
case *map[string]UUID:
return *i.(*map[string]UUID)
case *map[int64]string:
return *i.(*map[int64]string)
case *map[int64]int64:
return *i.(*map[int64]int64)
case *map[int64][]byte:
return *i.(*map[int64][]byte)
case *map[int64]bool:
return *i.(*map[int64]bool)
case *map[int64]float32:
return *i.(*map[int64]float32)
case *map[int64]float64:
return *i.(*map[int64]float64)
case *map[int64]int32:
return *i.(*map[int64]int32)
case *map[int64]UUID:
return *i.(*map[int64]UUID)
case *map[bool]string:
return *i.(*map[bool]string)
case *map[bool]int64:
return *i.(*map[bool]int64)
case *map[bool][]byte:
return *i.(*map[bool][]byte)
case *map[bool]bool:
return *i.(*map[bool]bool)
case *map[bool]float32:
return *i.(*map[bool]float32)
case *map[bool]float64:
return *i.(*map[bool]float64)
case *map[bool]int32:
return *i.(*map[bool]int32)
case *map[bool]UUID:
return *i.(*map[bool]UUID)
case *map[float32]string:
return *i.(*map[float32]string)
case *map[float32]int64:
return *i.(*map[float32]int64)
case *map[float32][]byte:
return *i.(*map[float32][]byte)
case *map[float32]bool:
return *i.(*map[float32]bool)
case *map[float32]float32:
return *i.(*map[float32]float32)
case *map[float32]float64:
return *i.(*map[float32]float64)
case *map[float32]int32:
return *i.(*map[float32]int32)
case *map[float32]UUID:
return *i.(*map[float32]UUID)
case *map[float64]string:
return *i.(*map[float64]string)
case *map[float64]int64:
return *i.(*map[float64]int64)
case *map[float64][]byte:
return *i.(*map[float64][]byte)
case *map[float64]bool:
return *i.(*map[float64]bool)
case *map[float64]float32:
return *i.(*map[float64]float32)
case *map[float64]float64:
return *i.(*map[float64]float64)
case *map[float64]int32:
return *i.(*map[float64]int32)
case *map[float64]UUID:
return *i.(*map[float64]UUID)
case *map[int32]string:
return *i.(*map[int32]string)
case *map[int32]int64:
return *i.(*map[int32]int64)
case *map[int32][]byte:
return *i.(*map[int32][]byte)
case *map[int32]bool:
return *i.(*map[int32]bool)
case *map[int32]float32:
return *i.(*map[int32]float32)
case *map[int32]float64:
return *i.(*map[int32]float64)
case *map[int32]int32:
return *i.(*map[int32]int32)
case *map[int32]UUID:
return *i.(*map[int32]UUID)
case *map[UUID]string:
return *i.(*map[UUID]string)
case *map[UUID]int64:
return *i.(*map[UUID]int64)
case *map[UUID][]byte:
return *i.(*map[UUID][]byte)
case *map[UUID]bool:
return *i.(*map[UUID]bool)
case *map[UUID]float32:
return *i.(*map[UUID]float32)
case *map[UUID]float64:
return *i.(*map[UUID]float64)
case *map[UUID]int32:
return *i.(*map[UUID]int32)
case *map[UUID]UUID:
return *i.(*map[UUID]UUID)
default:
return i
}
return reflect.Indirect(reflect.ValueOf(i)).Interface()

}

// SliceMap is a helper function to make the API easier to use
Expand All @@ -359,7 +46,7 @@ func (iter *Iter) SliceMap() ([]map[string]interface{}, error) {
}
interfacesToScan := make([]interface{}, 0)
for _, column := range iter.Columns() {
i := ptrOfType(column.TypeInfo)
i := column.TypeInfo.New()
interfacesToScan = append(interfacesToScan, i)
}
dataToReturn := make([]map[string]interface{}, 0)
Expand Down

0 comments on commit 355de42

Please sign in to comment.