github.com/optim-corp/cios-golang-sdk@v0.5.1/openapi/codegen/go-model/model.mustache

{{>partial_header}}
package {{packageName}}
{{#models}}{{#imports}}
{{#-first}}import (
{{/-first}}	"{{import}}"{{#-last}}
)
{{/-last}}{{/imports}}{{#model}}{{#isEnum}}{{#description}}// {{{classname}}} : {{{description}}}{{/description}}
type {{{name}}} {{^format}}{{dataType}}{{/format}}{{#format}}{{{format}}}{{/format}}

// List of {{{name}}}
const (
	{{#allowableValues}}
	{{#enumVars}}
	{{{classname}}}_{{name}} {{{classname}}} = {{{value}}}
	{{/enumVars}}
	{{/allowableValues}}
){{/isEnum}}{{^isEnum}}{{#description}}
// {{classname}} - {{{description}}}{{/description}}
type {{classname}} struct {
{{#vars}}{{#description}}
	// {{{description}}}{{/description}}
	{{name}} {{#isNullable}}*{{/isNullable}}{{{dataType}}} `json:"{{baseName}}{{^required}},omitempty{{/required}}"{{#vendorExtensions.x-go-custom-tag}} {{{.}}}{{/vendorExtensions.x-go-custom-tag}}`
{{/vars}}
}

type {{classname}}Stream []{{classname}}

func {{classname}}StreamOf(arg ...{{classname}}) *{{classname}}Stream {
	return (*{{classname}}Stream)(&arg)
}
func {{classname}}StreamFrom(arg []{{classname}}) *{{classname}}Stream {
	return (*{{classname}}Stream)(&arg)
}

func (self *{{classname}}Stream) Add(arg {{classname}}) *{{classname}}Stream {
	return self.AddAll(arg)

}

func (self *{{classname}}Stream) AddAll(arg ...{{classname}}) *{{classname}}Stream {
	*self = append(*self, arg...)
	return self
}

func (self *{{classname}}Stream) AddSafe(arg *{{classname}}) *{{classname}}Stream {
    if arg != nil {
        self.Add(*arg)
    }
	return self

}
func (self *{{classname}}Stream) AllMatch(fn func(arg {{classname}}, index int) bool) bool {
	for i, v := range *self {
		if !fn(v, i) {
			return false
		}
	}
	return true
}

func (self *{{classname}}Stream) AnyMatch(fn func(arg {{classname}}, index int) bool) bool {
	for i, v := range *self {
		if fn(v, i) {
			return true
		}
	}
	return false
}
func (self *{{classname}}Stream) Clone() *{{classname}}Stream {
	temp := {{classname}}StreamOf()
	*temp = *self
	return temp
}

func (self *{{classname}}Stream) Copy() *{{classname}}Stream {
	return self.Clone()
}

func (self *{{classname}}Stream) Concat(arg []{{classname}}) *{{classname}}Stream {
	return self.AddAll(arg...)
}

func (self *{{classname}}Stream) Delete(index int) *{{classname}}Stream {
	if len(*self) > index+1 {
		*self = append((*self)[:index], (*self)[index+1:]...)
	} else {
		*self = append((*self)[:index])
	}
	return self
}

func (self *{{classname}}Stream) DeleteRange(startIndex int, endIndex int) *{{classname}}Stream {
	*self = append((*self)[:startIndex], (*self)[endIndex+1:]...)
	return self
}

func (self *{{classname}}Stream) Filter(fn func(arg {{classname}}, index int) bool) *{{classname}}Stream {
	_array := []{{classname}}{}
	for i, v := range *self {
		if fn(v, i) {
			_array = append(_array, v)
		}
	}
	*self = _array
	return self
}

func (self *{{classname}}Stream) Find(fn func(arg {{classname}}, index int) bool) *{{classname}} {
	i := self.FindIndex(fn)
	if -1 != i {
		return &(*self)[i]
	}
	return nil
}

func (self *{{classname}}Stream) FindIndex(fn func(arg {{classname}}, index int) bool) int {
	for i, v := range *self {
		if fn(v, i) {
			return i
		}
	}
	return -1
}

func (self *{{classname}}Stream) First() *{{classname}} {
	return self.Get(0)
}

func (self *{{classname}}Stream) ForEach(fn func(arg {{classname}}, index int)) *{{classname}}Stream {
	for i, v := range *self {
		fn(v, i)
	}
	return self
}
func (self *{{classname}}Stream) ForEachRight(fn func(arg {{classname}}, index int)) *{{classname}}Stream {
	for i := len(*self) - 1; i >= 0; i-- {
		fn((*self)[i], i)
	}
	return self
}
func (self *{{classname}}Stream) GroupBy(fn func(arg {{classname}}, index int) string) map[string][]{{classname}} {
    m := map[string][]{{classname}}{}
    for i, v := range *self {
        key := fn(v, i)
        m[key] = append(m[key], v)
    }
    return m
}
func (self *{{classname}}Stream) GroupByValues(fn func(arg {{classname}}, index int) string) [][]{{classname}} {
	tmp := [][]{{classname}}{}
	m := self.GroupBy(fn)
	for _, v := range m {
		tmp = append(tmp, v)
	}
	return tmp
}
func (self *{{classname}}Stream) IsEmpty() bool {
	if self.Len() == 0 {
		return true
	}
	return false
}
func (self *{{classname}}Stream) IsPreset() bool {
	return !self.IsEmpty()
}
func (self *{{classname}}Stream) Last() *{{classname}} {
	return self.Get(self.Len() - 1)
}

func (self *{{classname}}Stream) Len() int {
    if self == nil {
		return 0
	}
	return len(*self)
}

func (self *{{classname}}Stream) Map(fn func(arg {{classname}}, index int) {{classname}}) *{{classname}}Stream {
	_array := make([]{{classname}}, 0, len(*self))
	for i, v := range *self {
		_array = append(_array, fn(v, i))
	}
	*self = _array
	return self
}

func (self *{{classname}}Stream) MapAny(fn func(arg {{classname}}, index int) interface{}) []interface{} {
	_array := make([]interface{}, 0, len(*self))
	for i, v := range *self {
		_array = append(_array, fn(v, i))
	}
	return _array
}

func (self *{{classname}}Stream) Map2Int(fn func(arg {{classname}}, index int) int) []int {
	_array := make([]int, 0, len(*self))
	for i, v := range *self {
		_array = append(_array, fn(v, i))
	}
	return _array
}

func (self *{{classname}}Stream) Map2Int32(fn func(arg {{classname}}, index int) int32) []int32 {
	_array := make([]int32, 0, len(*self))
	for i, v := range *self {
		_array = append(_array, fn(v, i))
	}
	return _array
}

func (self *{{classname}}Stream) Map2Int64(fn func(arg {{classname}}, index int) int64) []int64 {
	_array := make([]int64, 0, len(*self))
	for i, v := range *self {
		_array = append(_array, fn(v, i))
	}
	return _array
}

func (self *{{classname}}Stream) Map2Float32(fn func(arg {{classname}}, index int) float32) []float32 {
	_array := make([]float32, 0, len(*self))
	for i, v := range *self {
		_array = append(_array, fn(v, i))
	}
	return _array
}

func (self *{{classname}}Stream) Map2Float64(fn func(arg {{classname}}, index int) float64) []float64 {
	_array := make([]float64, 0, len(*self))
	for i, v := range *self {
		_array = append(_array, fn(v, i))
	}
	return _array
}

func (self *{{classname}}Stream) Map2Bool(fn func(arg {{classname}}, index int) bool) []bool {
	_array := make([]bool, 0, len(*self))
	for i, v := range *self {
		_array = append(_array, fn(v, i))
	}
	return _array
}

func (self *{{classname}}Stream) Map2Bytes(fn func(arg {{classname}}, index int) []byte) [][]byte {
	_array := make([][]byte, 0, len(*self))
	for i, v := range *self {
		_array = append(_array, fn(v, i))
	}
	return _array
}

func (self *{{classname}}Stream) Map2String(fn func(arg {{classname}}, index int) string) []string {
	_array := make([]string, 0, len(*self))
	for i, v := range *self {
		_array = append(_array, fn(v, i))
	}
	return _array
}

func (self *{{classname}}Stream) NoneMatch(fn func(arg {{classname}}, index int) bool) bool {
	return !self.AnyMatch(fn)
}

func (self *{{classname}}Stream) Get(index int) *{{classname}} {
	if self.Len() > index && index >= 0 {
		return &(*self)[index]
	}
	return nil
}
func (self *{{classname}}Stream) ReduceInit(fn func(result, current {{classname}}, index int) {{classname}}, initialValue {{classname}}) *{{classname}}Stream {
	result := []{{classname}}{}
	for i, v := range *self {
		if i == 0 {
			result = append(result, fn(initialValue, v, i))
		} else {
			result = append(result, fn(result[i-1], v, i))
		}
	}
	*self = result
	return self
}
func (self *{{classname}}Stream) Reduce(fn func(result, current {{classname}}, index int) {{classname}}) *{{classname}}Stream {
	result := []{{classname}}{}
	for i, v := range *self {
		if i == 0 {
			result = append(result, fn({{classname}}{}, v, i))
		} else {
			result = append(result, fn(result[i-1], v, i))
		}
	}
	*self = result
	return self
}
func (self *{{classname}}Stream) ReduceInterface(fn func(result interface{}, current {{classname}}, index int) interface{}) []interface{} {
	result := []interface{}{}
	for i, v := range *self {
		if i == 0 {
			result = append(result, fn({{classname}}{}, v, i))
		} else {
			result = append(result, fn(result[i-1], v, i))
		}
	}
	return result
}
func (self *{{classname}}Stream) ReduceString(fn func(result string, current {{classname}}, index int) string) []string {
	result := []string{}
	for i, v := range *self {
		if i == 0 {
			result = append(result, fn("", v, i))
		} else {
			result = append(result, fn(result[i-1], v, i))
		}
	}
	return result
}
func (self *{{classname}}Stream) ReduceInt(fn func(result int, current {{classname}}, index int) int) []int {
	result := []int{}
	for i, v := range *self {
		if i == 0 {
			result = append(result, fn(0, v, i))
		} else {
			result = append(result, fn(result[i-1], v, i))
		}
	}
	return result
}
func (self *{{classname}}Stream) ReduceInt32(fn func(result int32, current {{classname}}, index int) int32) []int32 {
	result := []int32{}
	for i, v := range *self {
		if i == 0 {
			result = append(result, fn(0, v, i))
		} else {
			result = append(result, fn(result[i-1], v, i))
		}
	}
	return result
}
func (self *{{classname}}Stream) ReduceInt64(fn func(result int64, current {{classname}}, index int) int64) []int64 {
	result := []int64{}
	for i, v := range *self {
		if i == 0 {
			result = append(result, fn(0, v, i))
		} else {
			result = append(result, fn(result[i-1], v, i))
		}
	}
	return result
}
func (self *{{classname}}Stream) ReduceFloat32(fn func(result float32, current {{classname}}, index int) float32) []float32 {
	result := []float32{}
	for i, v := range *self {
		if i == 0 {
			result = append(result, fn(0.0, v, i))
		} else {
			result = append(result, fn(result[i-1], v, i))
		}
	}
	return result
}
func (self *{{classname}}Stream) ReduceFloat64(fn func(result float64, current {{classname}}, index int) float64) []float64 {
	result := []float64{}
	for i, v := range *self {
		if i == 0 {
			result = append(result, fn(0.0, v, i))
		} else {
			result = append(result, fn(result[i-1], v, i))
		}
	}
	return result
}
func (self *{{classname}}Stream) ReduceBool(fn func(result bool, current {{classname}}, index int) bool) []bool {
	result := []bool{}
	for i, v := range *self {
		if i == 0 {
			result = append(result, fn(false, v, i))
		} else {
			result = append(result, fn(result[i-1], v, i))
		}
	}
	return result
}
func (self *{{classname}}Stream) Reverse() *{{classname}}Stream {
	_array := make([]{{classname}}, 0, len(*self))
	for i := len(*self) - 1; i >= 0; i-- {
		_array = append(_array, (*self)[i])
	}
	*self = _array
	return self
}

func (self *{{classname}}Stream) Replace(fn func(arg {{classname}}, index int) {{classname}}) *{{classname}}Stream {
	for i, v := range *self {
		(*self)[i] = fn(v, i)
	}
	return self
}

func (self *{{classname}}Stream) Set(index int, val {{classname}}) {
	if len(*self) > index {
		(*self)[index] = val
	}
}

func (self *{{classname}}Stream) Slice(startIndex int, n int) *{{classname}}Stream {
    last := startIndex+n
    if len(*self)-1 < startIndex {
        *self = []{{classname}}{}
    } else if len(*self) < last {
        *self = (*self)[startIndex:len(*self)]
    } else {
        *self = (*self)[startIndex:last]
    }
	return self
}

func (self *{{classname}}Stream) ToList() []{{classname}} {
	return self.Val()
}

func (self *{{classname}}Stream) Val() []{{classname}} {
    if self == nil {
        return []{{classname}}{}
    }
	return *self
}

{{/isEnum}}{{/model}}{{/models}}