Checks if this is an array containing only strings

@param Mixed Values to test
@return boolean True if all values are strings
331625
private function isStringArray($values) {
        if (!is_array($values)) {
            return false;
        }

        return array_reduce($values, function($res, $value) {
            return $res && is_string($value);
        }, true);
    }
1077059
private function isStringDQLQuery($value)
    {
        $keysWord = array(
            "SELECT ",
            " FROM ",
            " WHERE "
        );

        foreach ($keysWord as $keyWord) {
            if (stripos($value, $keyWord) !== false) {
                return true;
            }
        }

        return false;
    }
146339
public function filterLanguageValues($values)
    {
        return array_unique(preg_split(
            '/\s*,\s*/u',
            preg_replace('/\s+/u', ' ', is_array($values) ? implode(',', $values) : $values),
            -1,
            PREG_SPLIT_NO_EMPTY
        ));
    }
517594
public function isNull()
    {
        $values = $this->getValue();
        if (is_array($values)) {
            return empty($values) || count($values) <= 0;
        } elseif (is_string($values)) {
            return !isset($values) || trim($values) === '';
        } else {
            return is_null($values);
        }
    }
252116
public static boolean isStringArrayEmpty(String[] arr) {
        boolean empty = true;
        if (arr != null) {
            if (arr.length > 0) {
                for (String s : arr) {
                    if (StringUtils.isNotBlank(s)) {
                        empty = false;
                        break;
                    }
                }
            }
        }
        return empty;
    }
1203143
public function contains($value)
    {
        foreach (array_keys($this->dataPlaceHolder) as $key) {
            $data = $this->dataPlaceHolder[$key];
            if ($value === $data || ($data instanceof Comparable && $data->equals($value))) {
                return true;
            }
        }

        return false;
    }
665114
public function contains(string $value): bool
    {
        try {
            $this->position($value);

            return true;
        } catch (SubstringException $e) {
            return false;
        }
    }
169553
private function validateArrayType($value): bool
    {
        if (is_array($value) === false) {
            return false;
        }
        $count = 0;
        foreach ($value as $i => $item) {
            //not a array, but a hash/map
            if ($count !== $i) {
                return false;
            }
            $count++;
        }
        return true;
    }
813746
public function isEmpty(): bool
    {
        return $this->isNull()
            || (is_array($this->value) && count($this->value) === 0)
            || (is_string($this->value) && strlen($this->value) === 0);
    }
142546
public static function isValid($value)
    {
        if (is_string($value)) {
            $value = [ $value ];
        }
        
        if (!is_array($value) || count($value) === 0) {
            return false;
        }

        foreach ($value as $ep) {
            if (!is_string($ep)) {
                return false;
            }
            $type = self::getType($ep);

            if ($type === null) {
                return false;
            }
        }
        return true;
    }
107728
public static boolean allEquals(final String value, final String... strings) {
        if (strings != null) {
            for (final String s : strings) {
                if (s == null && value != null || s != null && !s.equals(value)) {
                    return false;
                }
            }
        } else {
            return value == null;
        }
        return true;

    }
603388
@SuppressWarnings("unchecked")
	public static <T> boolean containsAny(T[] array, T... values) {
		for (T value : values) {
			if(contains(array, value)) {
				return true;
			}
		}
		return false;
	}
928660
function Check($value)
    {
        $success = true;
        $strings = System\Str::SplitLines($value);
        foreach ($strings as $string)
        {
            $success = parent::Check($string);
            if (!$success)
                break;
        }
        
        //The value is temporarily set to the substrings
        //when calling the parent check function above,
        //so we have to store it here, not before the loop:
        $this->SetValue($value);
        return $success;
    }
863606
public function containsAll($items)
    {
        $values = $this->getValues();
        foreach($items as $item)
        {
            if (!in_array($item, $values, true))
            {
                return false;
            }
        }
        return true;
    }
1083679
protected function isSelected($value)
    {
        $selectedValue = $this->getSelectedValue();
        if ($value === $selectedValue || (string)$value === $selectedValue) {
            return true;
        }
        if ($this->hasArgument('multiple')) {
            if ($selectedValue === null && $this->arguments['selectAllByDefault'] === true) {
                return true;
            } elseif (is_array($selectedValue) && in_array($value, $selectedValue)) {
                return true;
            }
        }
        return false;
    }
1117969
public function validateArray(Array $values)
    {
        if (count($this->getValidationRules())) {
            $validator = Validator::make($values, $this->getValidationRules());

            if ($validator->fails()) {
                return $validator->errors();
            }
        }

        return True;
    }
691384
public static boolean contains(final String string, final String[] strings) {
        if (null == strings) {
            return false;
        }

        return Arrays.stream(strings).anyMatch(str -> StringUtils.equals(string, str));
    }