/*
	{4} ({1} and []{1})
	--------------------------------------------------
*/

// {4} gets the value as a {1}, returns the optionalDefault
// value or a system default object if the value is the wrong type.
func (v *Value) {4}(optionalDefault ...{1}) {1} {
	if s, ok := v.data.({1}); ok {
		return s
	}
	if len(optionalDefault) == 1 {
		return optionalDefault[0]
	}
	return {3}
}

// Must{4} gets the value as a {1}.
//
// Panics if the object is not a {1}.
func (v *Value) Must{4}() {1} {
	return v.data.({1})
}

// {4}Slice gets the value as a []{1}, returns the optionalDefault
// value or nil if the value is not a []{1}.
func (v *Value) {4}Slice(optionalDefault ...[]{1}) []{1} {
	if s, ok := v.data.([]{1}); ok {
		return s
	}
	if len(optionalDefault) == 1 {
		return optionalDefault[0]
	}
	return nil
}

// Must{4}Slice gets the value as a []{1}.
//
// Panics if the object is not a []{1}.
func (v *Value) Must{4}Slice() []{1} {
	return v.data.([]{1})
}

// Is{4} gets whether the object contained is a {1} or not.
func (v *Value) Is{4}() bool {
  _, ok := v.data.({1})
  return ok
}

// Is{4}Slice gets whether the object contained is a []{1} or not.
func (v *Value) Is{4}Slice() bool {
	_, ok := v.data.([]{1})
	return ok
}

// Each{4} calls the specified callback for each object
// in the []{1}.
//
// Panics if the object is the wrong type.
func (v *Value) Each{4}(callback func(int, {1}) bool) *Value {

	for index, val := range v.Must{4}Slice() {
		carryon := callback(index, val)
		if carryon == false {
			break
		}
	}

	return v

}

// Where{4} uses the specified decider function to select items
// from the []{1}.  The object contained in the result will contain
// only the selected items.
func (v *Value) Where{4}(decider func(int, {1}) bool) *Value {

	var selected []{1}

	v.Each{4}(func(index int, val {1}) bool {
		shouldSelect := decider(index, val)
		if shouldSelect == false {
			selected = append(selected, val)
		}
		return true
	})

	return &Value{data:selected}

}

// Group{4} uses the specified grouper function to group the items
// keyed by the return of the grouper.  The object contained in the
// result will contain a map[string][]{1}.
func (v *Value) Group{4}(grouper func(int, {1}) string) *Value {

	groups := make(map[string][]{1})

	v.Each{4}(func(index int, val {1}) bool {
		group := grouper(index, val)
		if _, ok := groups[group]; !ok {
			groups[group] = make([]{1}, 0)
		}
		groups[group] = append(groups[group], val)
		return true
	})

	return &Value{data:groups}

}

// Replace{4} uses the specified function to replace each {1}s
// by iterating each item.  The data in the returned result will be a
// []{1} containing the replaced items.
func (v *Value) Replace{4}(replacer func(int, {1}) {1}) *Value {

	arr := v.Must{4}Slice()
	replaced := make([]{1}, len(arr))

	v.Each{4}(func(index int, val {1}) bool {
		replaced[index] = replacer(index, val)
		return true
	})

	return &Value{data:replaced}

}

// Collect{4} uses the specified collector function to collect a value
// for each of the {1}s in the slice.  The data returned will be a
// []interface{}.
func (v *Value) Collect{4}(collector func(int, {1}) interface{}) *Value {

	arr := v.Must{4}Slice()
	collected := make([]interface{}, len(arr))

	v.Each{4}(func(index int, val {1}) bool {
		collected[index] = collector(index, val)
		return true
	})

	return &Value{data:collected}
}

// ************************************************************
// TESTS
// ************************************************************

func Test{4}(t *testing.T) {

  val := {1}( {2} )
	m := map[string]interface{}{"value": val, "nothing": nil}
	assert.Equal(t, val, New(m).Get("value").{4}())
	assert.Equal(t, val, New(m).Get("value").Must{4}())
	assert.Equal(t, {1}({3}), New(m).Get("nothing").{4}())
	assert.Equal(t, val, New(m).Get("nothing").{4}({2}))

	assert.Panics(t, func() {
		New(m).Get("age").Must{4}()
	})

}

func Test{4}Slice(t *testing.T) {

  val := {1}( {2} )
	m := map[string]interface{}{"value": []{1}{ val }, "nothing": nil}
	assert.Equal(t, val, New(m).Get("value").{4}Slice()[0])
	assert.Equal(t, val, New(m).Get("value").Must{4}Slice()[0])
	assert.Equal(t, []{1}(nil), New(m).Get("nothing").{4}Slice())
	assert.Equal(t, val, New(m).Get("nothing").{4}Slice( []{1}{ {1}({2}) } )[0])

	assert.Panics(t, func() {
		New(m).Get("nothing").Must{4}Slice()
	})

}

func TestIs{4}(t *testing.T) {

	var v *Value

	v = &Value{data: {1}({2})}
	assert.True(t, v.Is{4}())

	v = &Value{data: []{1}{ {1}({2}) }}
	assert.True(t, v.Is{4}Slice())

}

func TestEach{4}(t *testing.T) {

	v := &Value{data: []{1}{ {1}({2}), {1}({2}), {1}({2}), {1}({2}), {1}({2}) }}
	count := 0
	replacedVals := make([]{1}, 0)
	assert.Equal(t, v, v.Each{4}(func(i int, val {1}) bool {

		count++
		replacedVals = append(replacedVals, val)

		// abort early
		if i == 2 {
			return false
		}

		return true

	}))

	assert.Equal(t, count, 3)
	assert.Equal(t, replacedVals[0], v.Must{4}Slice()[0])
	assert.Equal(t, replacedVals[1], v.Must{4}Slice()[1])
	assert.Equal(t, replacedVals[2], v.Must{4}Slice()[2])

}

func TestWhere{4}(t *testing.T) {

	v := &Value{data: []{1}{ {1}({2}), {1}({2}), {1}({2}), {1}({2}), {1}({2}), {1}({2}) }}

	selected := v.Where{4}(func(i int, val {1}) bool {
		return i%2==0
	}).Must{4}Slice()

	assert.Equal(t, 3, len(selected))

}

func TestGroup{4}(t *testing.T) {

	v := &Value{data: []{1}{ {1}({2}), {1}({2}), {1}({2}), {1}({2}), {1}({2}), {1}({2}) }}

	grouped := v.Group{4}(func(i int, val {1}) string {
		return fmt.Sprintf("%v", i%2==0)
	}).data.(map[string][]{1})

	assert.Equal(t, 2, len(grouped))
	assert.Equal(t, 3, len(grouped["true"]))
	assert.Equal(t, 3, len(grouped["false"]))

}

func TestReplace{4}(t *testing.T) {

	v := &Value{data: []{1}{ {1}({2}), {1}({2}), {1}({2}), {1}({2}), {1}({2}), {1}({2}) }}

	rawArr := v.Must{4}Slice()

	replaced := v.Replace{4}(func(index int, val {1}) {1} {
		if index < len(rawArr)-1 {
			return rawArr[index+1]
		}
		return rawArr[0]
	})

	replacedArr := replaced.Must{4}Slice()
	if assert.Equal(t, 6, len(replacedArr)) {
		assert.Equal(t, replacedArr[0], rawArr[1])
		assert.Equal(t, replacedArr[1], rawArr[2])
		assert.Equal(t, replacedArr[2], rawArr[3])
		assert.Equal(t, replacedArr[3], rawArr[4])
		assert.Equal(t, replacedArr[4], rawArr[5])
		assert.Equal(t, replacedArr[5], rawArr[0])
	}

}

func TestCollect{4}(t *testing.T) {

	v := &Value{data: []{1}{ {1}({2}), {1}({2}), {1}({2}), {1}({2}), {1}({2}), {1}({2}) }}

	collected := v.Collect{4}(func(index int, val {1}) interface{} {
		return index
	})

	collectedArr := collected.MustInterSlice()
	if assert.Equal(t, 6, len(collectedArr)) {
		assert.Equal(t, collectedArr[0], 0)
		assert.Equal(t, collectedArr[1], 1)
		assert.Equal(t, collectedArr[2], 2)
		assert.Equal(t, collectedArr[3], 3)
		assert.Equal(t, collectedArr[4], 4)
		assert.Equal(t, collectedArr[5], 5)
	}

}
