golang-thrift-dev 0.0~git20121118-1 / usr / share / gocode / src / thrift / tfield.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 (
	"sort"
)

/**
 * Helper class that encapsulates field metadata.
 *
 */
type TField interface {
	Name() string
	TypeId() TType
	Id() int
	String() string
	CompareTo(other interface{}) (int, bool)
	Equals(other interface{}) bool
}

type tField struct {
	name   string
	typeId TType
	id     int
}

func NewTFieldDefault() TField {
	return ANONYMOUS_FIELD
}

func NewTField(n string, t TType, i int) TField {
	return &tField{name: n, typeId: t, id: i}
}

func (p *tField) Name() string {
	if p == nil {
		return ""
	}
	return p.name
}

func (p *tField) TypeId() TType {
	if p == nil {
		return TType(VOID)
	}
	return p.typeId
}

func (p *tField) Id() int {
	if p == nil {
		return -1
	}
	return p.id
}

func (p *tField) String() string {
	if p == nil {
		return "<nil>"
	}
	return "<TField name:'" + p.name + "' type:" + string(p.typeId) + " field-id:" + string(p.id) + ">"
}

func (p *tField) CompareTo(other interface{}) (int, bool) {
	if other == nil {
		return 1, true
	}
	if data, ok := other.(TField); ok {
		if p.Id() != data.Id() {
			return CompareInt(p.Id(), data.Id()), true
		}
		if p.TypeId() != data.TypeId() {
			return CompareByte(byte(p.TypeId()), byte(data.TypeId())), true
		}
		return CompareString(p.Name(), data.Name()), true
	}
	return 0, false
}

func (p *tField) Equals(other interface{}) bool {
	if p == nil {
		return other == nil
	}
	if other == nil {
		return false
	}
	if data, ok := other.(TField); ok {
		return p.TypeId() == data.TypeId() && p.Id() == data.Id()
	}
	return false
}

var ANONYMOUS_FIELD TField

type tFieldArray []TField

func (p tFieldArray) Len() int {
	return len(p)
}

func (p tFieldArray) Less(i, j int) bool {
	return p[i].Id() < p[j].Id()
}

func (p tFieldArray) Swap(i, j int) {
	p[i], p[j] = p[j], p[i]
}

type TFieldContainer interface {
	TContainer
	FieldNameFromFieldId(id int) string
	FieldIdFromFieldName(name string) int
	FieldFromFieldId(id int) TField
	FieldFromFieldName(name string) TField
	At(i int) TField
	Iter() <-chan TField
}

type tFieldContainer struct {
	fields         []TField
	nameToFieldMap map[string]TField
	idToFieldMap   map[int]TField
}

func NewTFieldContainer(fields []TField) TFieldContainer {
	sortedFields := make([]TField, len(fields))
	nameToFieldMap := make(map[string]TField)
	idToFieldMap := make(map[int]TField)
	for i, field := range fields {
		sortedFields[i] = field
		idToFieldMap[field.Id()] = field
		if field.Name() != "" {
			nameToFieldMap[field.Name()] = field
		}
	}
	sort.Sort(tFieldArray(sortedFields))
	return &tFieldContainer{
		fields:         fields,
		nameToFieldMap: nameToFieldMap,
		idToFieldMap:   idToFieldMap,
	}
}

func (p *tFieldContainer) FieldNameFromFieldId(id int) string {
	if field, ok := p.idToFieldMap[id]; ok {
		return field.Name()
	}
	return ""
}

func (p *tFieldContainer) FieldIdFromFieldName(name string) int {
	if field, ok := p.nameToFieldMap[name]; ok {
		return field.Id()
	}
	return -1
}

func (p *tFieldContainer) FieldFromFieldId(id int) TField {
	if field, ok := p.idToFieldMap[id]; ok {
		return field
	}
	return ANONYMOUS_FIELD
}

func (p *tFieldContainer) FieldFromFieldName(name string) TField {
	if field, ok := p.nameToFieldMap[name]; ok {
		return field
	}
	return ANONYMOUS_FIELD
}

func (p *tFieldContainer) Len() int {
	return len(p.fields)
}

func (p *tFieldContainer) At(i int) TField {
	return p.FieldFromFieldId(i)
}

func (p *tFieldContainer) Contains(data interface{}) bool {
	if i, ok := data.(int); ok {
		for _, field := range p.fields {
			if field.Id() == i {
				return true
			}
		}
	} else if i, ok := data.(int16); ok {
		for _, field := range p.fields {
			if field.Id() == int(i) {
				return true
			}
		}
	} else if s, ok := data.(string); ok {
		for _, field := range p.fields {
			if field.Name() == s {
				return true
			}
		}
	} else if f, ok := data.(TField); ok {
		for _, field := range p.fields {
			if field.Equals(f) {
				return true
			}
		}
	}
	return false
}

func (p *tFieldContainer) Equals(other interface{}) bool {
	if other == nil {
		return false
	}
	if data, ok := other.(TFieldContainer); ok {
		if p.Len() != data.Len() {
			return false
		}
		for _, field := range p.fields {
			if !data.Contains(field) {
				return false
			}
		}
		return true
	}
	return false
}

func (p *tFieldContainer) CompareTo(other interface{}) (int, bool) {
	if other == nil {
		return 1, true
	}
	if data, ok := other.(TFieldContainer); ok {
		cont, ok2 := data.(*tFieldContainer)
		if ok2 && p == cont {
			return 0, true
		}
		if cmp := CompareInt(p.Len(), data.Len()); cmp != 0 {
			return cmp, true
		}
		for _, field := range p.fields {
			if cmp, ok3 := field.CompareTo(data.At(field.Id())); !ok3 || cmp != 0 {
				return cmp, ok3
			}
		}
		return 0, true
	}
	return 0, false
}

func (p *tFieldContainer) Iter() <-chan TField {
	c := make(chan TField)
	go p.iterate(c)
	return c
}

func (p *tFieldContainer) iterate(c chan<- TField) {
	for _, v := range p.fields {
		c <- v
	}
	close(c)
}

func init() {
	ANONYMOUS_FIELD = NewTField("", STOP, 0)
}