golang-thrift-dev 0.0~git20121118-1 / usr / share / gocode / src / thrift / tmap.go

/*
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements. See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership. The ASF licenses this file
 * to you 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.
 */

package thrift

import (
	"bytes"
	"container/list"
	"reflect"
)

/**
 * Helper class that encapsulates map metadata.
 *
 */
type TMap interface {
	KeyType() TType
	ValueType() TType
	Len() int
	Set(key, value interface{})
	Get(key interface{}) (interface{}, bool)
	Contains(key interface{}) bool
	Iter() <-chan TMapElem
	KeyIter() <-chan interface{}
	ValueIter() <-chan interface{}
	Keys() []interface{}
	Values() []interface{}
	Less(other interface{}) bool
	Equals(other interface{}) bool
	CompareTo(other interface{}) (int, bool)
}

type TMapElem interface {
	Key() interface{}
	Value() interface{}
}

type tMap struct {
	keyType   TType
	valueType TType
	size      int
	l         *list.List
	b         map[bool]interface{}
	i08       map[byte]interface{}
	i16       map[int16]interface{}
	i32       map[int32]interface{}
	i64       map[int64]interface{}
	f64       map[float64]interface{}
	s         map[string]interface{}
}

type tMapElem struct {
	key   interface{}
	value interface{}
}

func (p *tMapElem) Key() interface{} {
	return p.key
}

func (p *tMapElem) Value() interface{} {
	return p.value
}

func NewTMapElem(k, v interface{}) TMapElem {
	return &tMapElem{key: k, value: v}
}

func NewTMap(k, v TType, s int) TMap {
	return &tMap{keyType: k, valueType: v, size: s, l: list.New()}
}

func NewTMapDefault() TMap {
	return NewTMap(STOP, STOP, 0)
}

func (p *tMap) KeyType() TType {
	return p.keyType
}

func (p *tMap) ValueType() TType {
	return p.valueType
}

func (p *tMap) Len() int {
	if p.l.Len() != 0 {
		return p.l.Len()
	}
	switch p.KeyType() {
	case STOP, VOID:
		return 0
	case BOOL:
		return len(p.b)
	case BYTE:
		return len(p.i08)
	case I16:
		return len(p.i16)
	case I32:
		return len(p.i32)
	case I64:
		return len(p.i64)
	case DOUBLE:
		return len(p.f64)
	case STRING, UTF8, UTF16:
		return len(p.s)
	default:
		return p.size
	}
	return p.size
}

func (p *tMap) Get(key interface{}) (interface{}, bool) {
	if p.KeyType().IsEmptyType() {
		return nil, false
	}
	if key == nil {
		for elem := p.l.Front(); elem != nil; elem = elem.Next() {
			e := elem.Value.(TMapElem)
			k := e.Key()
			if k == nil {
				return e.Value(), true
			}
		}
		return nil, false
	}
	useKey, ok := p.KeyType().CoerceData(key)
	if !ok {
		return nil, false
	}
	switch p.KeyType() {
	case STOP, VOID:
		// if here, then we don't have a key type yet and key is not nil
		// so this is pretty much an empty map
		return nil, false
	case BOOL:
		m := p.b
		if m == nil {
			return nil, false
		}
		if v, ok := m[useKey.(bool)]; ok {
			return v, true
		}
		return nil, true
	case BYTE:
		m := p.i08
		if v, ok := m[useKey.(byte)]; ok {
			return v, true
		}
		return nil, false
	case DOUBLE:
		m := p.f64
		if m == nil {
			return nil, false
		}
		if v, ok := m[useKey.(float64)]; ok {
			return v, true
		}
		return nil, false
	case I16:
		m := p.i16
		if m == nil {
			return nil, false
		}
		if v, ok := m[useKey.(int16)]; ok {
			return v, true
		}
		return nil, false
	case I32:
		m := p.i32
		if m == nil {
			return nil, false
		}
		if v, ok := m[useKey.(int32)]; ok {
			return v, true
		}
		return nil, false
	case I64:
		m := p.i64
		if m == nil {
			return nil, false
		}
		if v, ok := m[useKey.(int64)]; ok {
			return v, true
		}
		return nil, false
	case STRING, UTF8, UTF16:
		// TODO(pomack) properly handle ENUM
		m := p.s
		if m == nil {
			return nil, false
		}
		if v, ok := m[useKey.(string)]; ok {
			return v, true
		}
		return nil, false
	case BINARY:
		for elem := p.l.Front(); elem != nil; elem = elem.Next() {
			e := elem.Value.(TMapElem)
			k := e.Key()
			if k == nil {
				continue
			}
			binkey, ok := k.([]byte)
			if ok {
				if bytes.Compare(binkey, useKey.([]byte)) == 0 {
					return e.Value(), true
				}
				continue
			}
			if reflect.DeepEqual(useKey, k) {
				return e.Value(), true
			}
		}
		return nil, false
	case STRUCT:
		for elem := p.l.Front(); elem != nil; elem = elem.Next() {
			e := elem.Value.(TMapElem)
			k := e.Key()
			if k == nil {
				continue
			}
			structkey, ok := k.(TStruct)
			if ok {
				if structkey.Equals(useKey.(TStruct)) {
					return e.Value(), true
				}
				continue
			}
			if reflect.DeepEqual(useKey, k) {
				return e.Value(), true
			}
		}
		return nil, false
	case MAP:
		for elem := p.l.Front(); elem != nil; elem = elem.Next() {
			e := elem.Value.(TMapElem)
			k := e.Key()
			if k == nil {
				continue
			}
			mapkey, ok := k.(TMap)
			if ok {
				if mapkey.Equals(useKey.(TMap)) {
					return e.Value(), true
				}
				continue
			}
			if reflect.DeepEqual(useKey, k) {
				return e.Value(), true
			}
		}
		return nil, false
	case SET:
		for elem := p.l.Front(); elem != nil; elem = elem.Next() {
			e := elem.Value.(TMapElem)
			k := e.Key()
			if k == nil {
				continue
			}
			setkey, ok := k.(TSet)
			if ok {
				if setkey.Equals(useKey.(TSet)) {
					return e.Value(), true
				}
				continue
			}
			if reflect.DeepEqual(useKey, k) {
				return e.Value(), true
			}
		}
		return nil, false
	case LIST:
		for elem := p.l.Front(); elem != nil; elem = elem.Next() {
			e := elem.Value.(TMapElem)
			k := e.Key()
			if k == nil {
				continue
			}
			listkey, ok := k.(TList)
			if ok {
				if listkey.Equals(useKey.(TList)) {
					return e.Value(), true
				}
				continue
			}
			if reflect.DeepEqual(useKey, k) {
				return e.Value(), true
			}
		}
		return nil, false
	default:
		panic("Invalid Thrift element type")
	}
	return nil, false
}

func (p *tMap) Set(key, value interface{}) {
	if p.KeyType() == STOP || p.KeyType() == VOID {
		p.keyType = TypeFromValue(key)
	}
	coercedKey, ok := p.KeyType().CoerceData(key)
	if !ok {
		return
	}
	if p.ValueType() == STOP || p.ValueType() == VOID {
		p.valueType = TypeFromValue(value)
	}
	coercedValue, ok := p.ValueType().CoerceData(value)
	if !ok {
		return
	}
	newElem := NewTMapElem(coercedKey, coercedValue)
	if !p.KeyType().IsBaseType() || p.KeyType() == BINARY {
		for elem := p.l.Front(); elem != nil; elem = elem.Next() {
			k := elem.Value.(TMapElem).Key()
			if cmp, ok := p.KeyType().Compare(coercedKey, k); ok && cmp >= 0 {
				if cmp == 0 {
					p.l.InsertAfter(newElem, elem)
					p.l.Remove(elem)
					return
				}
				p.l.InsertBefore(newElem, elem)
				return
			}
		}
		p.l.PushBack(newElem)
		return
	}
	if key == nil {
		return
	}
	switch p.KeyType() {
	case STOP, VOID:
		// if here, then we don't have a key type yet and key is not nil
		// so this is pretty much an empty map
		return
	case BOOL:
		if p.b == nil {
			p.b = make(map[bool]interface{})
		}
		b := coercedKey.(bool)
		p.b[b] = value
	case BYTE:
		if p.i08 == nil {
			p.i08 = make(map[byte]interface{})
		}
		b := coercedKey.(byte)
		p.i08[b] = value
	case DOUBLE:
		if p.f64 == nil {
			p.f64 = make(map[float64]interface{})
		}
		b := coercedKey.(float64)
		p.f64[b] = value
	case I16:
		if p.i16 == nil {
			p.i16 = make(map[int16]interface{})
		}
		b := coercedKey.(int16)
		p.i16[b] = value
	case I32:
		if p.i32 == nil {
			p.i32 = make(map[int32]interface{})
		}
		b := coercedKey.(int32)
		p.i32[b] = value
	case I64:
		if p.i64 == nil {
			p.i64 = make(map[int64]interface{})
		}
		b := coercedKey.(int64)
		p.i64[b] = value
	case STRING, UTF8, UTF16:
		if p.s == nil {
			p.s = make(map[string]interface{})
		}
		b := coercedKey.(string)
		p.s[b] = value
	case BINARY, STRUCT, MAP, SET, LIST:
		panic("Should never be here because type is " + p.KeyType().String())
	default:
		panic("Should never be here because type is " + p.KeyType().String())
	}
}

func (p *tMap) Contains(key interface{}) bool {
	coercedKey, ok := p.KeyType().CoerceData(key)
	if !ok {
		return false
	}
	if coercedKey == nil {
		for elem := p.l.Front(); elem != nil; elem = elem.Next() {
			k := elem.Value.(TMapElem).Key()
			if k == nil {
				return true
			}
		}
		return false
	}
	if !ok {
		return false
	}
	switch p.KeyType() {
	case STOP:
		// if here, then we don't have a key type yet and key is not nil
		// so this is pretty much an empty map
		return false
	case VOID:
		// if here, then we don't have a key type yet and key is not nil
		// so this is pretty much an empty map
		return false
	case BOOL:
		m := p.b
		if m == nil {
			return false
		}
		_, ok := m[coercedKey.(bool)]
		return ok
	case BYTE:
		m := p.i08
		_, ok := m[coercedKey.(byte)]
		return ok
	case DOUBLE:
		m := p.f64
		if m == nil {
			return false
		}
		_, ok := m[coercedKey.(float64)]
		return ok
	case I16:
		m := p.i16
		if m == nil {
			return false
		}
		_, ok := m[coercedKey.(int16)]
		return ok
	case I32:
		m := p.i32
		if m == nil {
			return false
		}
		_, ok := m[coercedKey.(int32)]
		return ok
	case I64:
		m := p.i64
		if m == nil {
			return false
		}
		_, ok := m[coercedKey.(int64)]
		return ok
	case STRING, UTF8, UTF16:
		// TODO(pomack) properly handle ENUM
		m := p.s
		if m == nil {
			return false
		}
		_, ok := m[coercedKey.(string)]
		return ok
	case BINARY:
		for elem := p.l.Front(); elem != nil; elem = elem.Next() {
			e := elem.Value.(TMapElem)
			k := e.Key()
			if k == nil {
				continue
			}
			binkey, ok := k.([]byte)
			if ok {
				if bytes.Compare(binkey, coercedKey.([]byte)) == 0 {
					return true
				}
				continue
			}
			if reflect.DeepEqual(coercedKey, k) {
				return true
			}
		}
		return false
	case STRUCT:
		for elem := p.l.Front(); elem != nil; elem = elem.Next() {
			e := elem.Value.(TMapElem)
			k := e.Key()
			if k == nil {
				continue
			}
			structkey, ok := k.(TStruct)
			if ok {
				if structkey.Equals(coercedKey.(TStruct)) {
					return true
				}
				continue
			}
			if reflect.DeepEqual(coercedKey, k) {
				return true
			}
		}
		return false
	case MAP:
		for elem := p.l.Front(); elem != nil; elem = elem.Next() {
			e := elem.Value.(TMapElem)
			k := e.Key()
			if k == nil {
				continue
			}
			mapkey, ok := k.(TMap)
			if ok {
				if mapkey.Equals(coercedKey.(TMap)) {
					return true
				}
				continue
			}
		}
		return false
	case SET:
		for elem := p.l.Front(); elem != nil; elem = elem.Next() {
			e := elem.Value.(TMapElem)
			k := e.Key()
			if k == nil {
				continue
			}
			setkey, ok := k.(TSet)
			if ok {
				if setkey.Equals(coercedKey.(TSet)) {
					return true
				}
				continue
			}
		}
		return false
	case LIST:
		for elem := p.l.Front(); elem != nil; elem = elem.Next() {
			e := elem.Value.(TMapElem)
			k := e.Key()
			if k == nil {
				continue
			}
			listkey, ok := k.(TList)
			if ok {
				if listkey.Equals(coercedKey.(TList)) {
					return true
				}
				continue
			}
		}
		return false
	default:
		panic("Invalid Thrift element type")
	}
	return false
}

// Iterate over all elements; driver for range
func (p *tMap) iterate(c chan<- TMapElem) {
	switch p.KeyType() {
	case STOP, VOID:
		close(c)
	case BOOL:
		for k, v := range p.b {
			c <- NewTMapElem(k, v)
		}
		close(c)
	case BYTE:
		for k, v := range p.i08 {
			c <- NewTMapElem(k, v)
		}
		close(c)
	case I16:
		for k, v := range p.i16 {
			c <- NewTMapElem(k, v)
		}
		close(c)
	case I32:
		for k, v := range p.i32 {
			c <- NewTMapElem(k, v)
		}
		close(c)
	case I64:
		for k, v := range p.i64 {
			c <- NewTMapElem(k, v)
		}
		close(c)
	case DOUBLE:
		for k, v := range p.f64 {
			c <- NewTMapElem(k, v)
		}
		close(c)
	case STRING, UTF8, UTF16:
		for k, v := range p.s {
			c <- NewTMapElem(k, v)
		}
		close(c)
	case BINARY, STRUCT, LIST, SET:
		for v := p.l.Front(); v != nil; v = v.Next() {
			c <- v.Value.(TMapElem)
		}
		close(c)
	default:
		panic("Invalid Thrift type")
	}
}

// Channel iterator for range.
func (p *tMap) Iter() <-chan TMapElem {
	c := make(chan TMapElem)
	go p.iterate(c)
	return c
}

// Iterate over all keys; driver for range
func (p *tMap) iterateKeys(c chan<- interface{}) {
	switch p.KeyType() {
	case STOP, VOID:
		close(c)
	case BOOL:
		for k, _ := range p.b {
			c <- k
		}
		close(c)
	case BYTE:
		for k, _ := range p.i08 {
			c <- k
		}
		close(c)
	case I16:
		for k, _ := range p.i16 {
			c <- k
		}
		close(c)
	case I32:
		for k, _ := range p.i32 {
			c <- k
		}
		close(c)
	case I64:
		for k, _ := range p.i64 {
			c <- k
		}
		close(c)
	case DOUBLE:
		for k, _ := range p.f64 {
			c <- k
		}
		close(c)
	case STRING, UTF8, UTF16:
		for k, _ := range p.s {
			c <- k
		}
		close(c)
	case BINARY, STRUCT, LIST, SET:
		for v := p.l.Front(); v != nil; v = v.Next() {
			c <- v.Value.(TMapElem).Key()
		}
		close(c)
	default:
		panic("Invalid Thrift type")
	}
}

func (p *tMap) KeyIter() <-chan interface{} {
	c := make(chan interface{})
	go p.iterateKeys(c)
	return c
}

// Iterate over all values; driver for range
func (p *tMap) iterateValues(c chan<- interface{}) {
	switch p.KeyType() {
	case STOP, VOID:
		close(c)
	case BOOL:
		for _, v := range p.b {
			c <- v
		}
		close(c)
	case BYTE:
		for _, v := range p.i08 {
			c <- v
		}
		close(c)
	case I16:
		for _, v := range p.i16 {
			c <- v
		}
		close(c)
	case I32:
		for _, v := range p.i32 {
			c <- v
		}
		close(c)
	case I64:
		for _, v := range p.i64 {
			c <- v
		}
		close(c)
	case DOUBLE:
		for _, v := range p.f64 {
			c <- v
		}
		close(c)
	case STRING, UTF8, UTF16:
		for _, v := range p.s {
			c <- v
		}
		close(c)
	case BINARY, STRUCT, LIST, SET:
		for v := p.l.Front(); v != nil; v = v.Next() {
			c <- v.Value.(TMapElem).Value()
		}
		close(c)
	default:
		panic("Invalid Thrift type")
	}
}

func (p *tMap) ValueIter() <-chan interface{} {
	c := make(chan interface{})
	go p.iterateValues(c)
	return c
}

func (p *tMap) Less(other interface{}) bool {
	cmp, ok := p.CompareTo(other)
	return ok && cmp > 0
}

func (p *tMap) Equals(other interface{}) bool {
	c, cok := p.CompareTo(other)
	return cok && c == 0
}

func (p *tMap) CompareTo(other interface{}) (int, bool) {
	return TType(MAP).Compare(p, other)
}

func (p *tMap) Keys() []interface{} {
	size := p.Len()
	values := make([]interface{}, size, size)
	i := 0
	for k := range p.KeyIter() {
		values[i] = k
		i++
	}
	return values
}

func (p *tMap) Values() []interface{} {
	size := p.Len()
	values := make([]interface{}, size, size)
	i := 0
	for v := range p.ValueIter() {
		values[i] = v
		i++
	}
	return values
}