/*
This method removes all the occurences of the second value from the
first array value.
*/
func (this *ArrayRemove) Apply(context Context, first, second value.Value) (value.Value, error) {
if first.Type() == value.MISSING {
return first, nil
}
if first.Type() != value.ARRAY {
return value.NULL_VALUE, nil
}
if second.Type() <= value.NULL {
return first, nil
}
fa := first.Actual().([]interface{})
if len(fa) == 0 {
return first, nil
}
ra := make([]interface{}, 0, len(fa))
for _, f := range fa {
if !second.Equals(value.NewValue(f)).Truth() {
ra = append(ra, f)
}
}
return value.NewValue(ra), nil
}
/*
This method checks to see if the values of the two input
expressions are equal, and if true then returns a positive
infinity using the math package method Inf(1). If not it
returns the first input value. Use the Equals method for the
two values to determine equality.
*/
func (this *PosInfIf) Apply(context Context, first, second value.Value) (value.Value, error) {
eq := first.Equals(second)
switch eq.Type() {
case value.MISSING, value.NULL:
return eq, nil
default:
if eq.Truth() {
return _POS_INF_VALUE, nil
} else {
return first, nil
}
}
}
/*
IN evaluates to TRUE if the right-hand-side first value is an array
and directly contains the left-hand-side second value. If either
of the input operands are missing, return missing value, and
if the second is not an array return null. Range over the elements of the
array and check if any element is equal to the first value, return true.
For all other cases, return false.
*/
func (this *In) Apply(context Context, first, second value.Value) (value.Value, error) {
if first.Type() == value.MISSING || second.Type() == value.MISSING {
return value.MISSING_VALUE, nil
} else if second.Type() != value.ARRAY {
return value.NULL_VALUE, nil
}
sa := second.Actual().([]interface{})
for _, s := range sa {
if first.Equals(value.NewValue(s)).Truth() {
return value.TRUE_VALUE, nil
}
}
return value.FALSE_VALUE, nil
}
/*
This method ranges through the array and returns the position
of the second value in the array (first value). If the input
values are of type missing return a missing value, and for all
non array values return null. If not found then return -1.
*/
func (this *ArrayPosition) Apply(context Context, first, second value.Value) (value.Value, error) {
if first.Type() == value.MISSING || second.Type() == value.MISSING {
return value.MISSING_VALUE, nil
} else if first.Type() != value.ARRAY {
return value.NULL_VALUE, nil
}
fa := first.Actual().([]interface{})
for i, f := range fa {
if second.Equals(value.NewValue(f)).Truth() {
return value.NewValue(float64(i)), nil
}
}
return value.NewValue(float64(-1)), nil
}
/*
WITHIN evaluates to TRUE if the right-hand-side first value contains
the left-hand-side second value (or name and value) as a child or
descendant (i.e. directly or indirectly). If either
of the input operands are missing, return missing value, and if
the first operand is not an array and the second is not an object
return a null value. Range through the descendants of the second
value object, and check if the first value is equal to each
descendant; return true. For all other cases return false.
*/
func (this *Within) Apply(context Context, first, second value.Value) (value.Value, error) {
if first.Type() == value.MISSING || second.Type() == value.MISSING {
return value.MISSING_VALUE, nil
} else if second.Type() != value.ARRAY && second.Type() != value.OBJECT {
return value.NULL_VALUE, nil
}
desc := second.Descendants(make([]interface{}, 0, 64))
for _, d := range desc {
if first.Equals(value.NewValue(d)).Truth() {
return value.TRUE_VALUE, nil
}
}
return value.FALSE_VALUE, nil
}
/*
This method appends the value into the array if it isnt
present. Range over the array and check if the value exists.
If it does return the array as is. If either of the input
argument types are missing, or not an array return a missing
and null value respectively.
*/
func (this *ArrayPut) Apply(context Context, first, second value.Value) (value.Value, error) {
if first.Type() == value.MISSING {
return value.MISSING_VALUE, nil
} else if first.Type() != value.ARRAY {
return value.NULL_VALUE, nil
} else if second.Type() == value.MISSING {
return first, nil
}
f := first.Actual().([]interface{})
for _, a := range f {
v := value.NewValue(a)
if second.Equals(v).Truth() {
return first, nil
}
}
ra := append(f, second)
return value.NewValue(ra), nil
}
func (this *Eq) Apply(context Context, first, second value.Value) (value.Value, error) {
return first.Equals(second), nil
}