Executes the TermSpec returning a set of stringified terms. This method does not use the TermSpec's {@link
com.davidbracewell.hermes.ml.feature.ValueCalculator}

@param hString the HString to process
@return a set of term counts
187952
public Set<String> unique(@NonNull HString hString) {
      return stream(hString).collect(Collectors.toSet());
   }
388112
public static double[] bbox(@NonNull LineString lineString) {
    List<Point> resultCoords = TurfMeta.coordAll(lineString);
    return bboxCalculator(resultCoords);
  }
290220
public Optional<Annotation> getTarget(HString hString) {
      if (hString == null || hString.document() == null) {
         return Optional.empty();
      }
      return hString.document().getAnnotation(target);
   }
935516
public static String getDigitsFromHexLiteral(String paramString) {
        Matcher matcher = SingleQuotedHexLiteral.matcher(paramString);
        if (matcher.matches()) {
            return matcher.group(1);
        }
        return null;
    }
1260453
static List<String> stringsWithEq(String name, @Nullable List<String> values) {
    List<String> result = new ArrayList<>();
    if (values != null) {
      for (String value : values) {
        result.addAll(stringWithEq(name, value));
      }
    }
    return result;
  }
254863
static List<String> getCommaTokens(String inString) {
        String input = inString.trim();
        List<String> tokens = new ArrayList<String>();
        String token;
        while (0 < input.length()) {
            if (COMMA == input.charAt(0)) {
                input = input.substring(1);
            }
            token = getNextCommaToken(input);

            input = input.substring(token.length());
            tokens.add(token.trim());
        }

        return tokens;

    }
1148692
public List<String> getStrings(String name, String delimiter) {
        String value = getString(name, null);
        if (StringUtils.isNullOrEmpty(value)) {
            return Collections.emptyList();
        }

        value = value.trim();
        // to handles cases where value is specified like [a,b, c]
        if (value.startsWith("[") && value.endsWith("]")) {
            value = value.substring(1, value.length() - 1);
        }
        return StringUtils.getList(value, delimiter);
    }
881336
def p_term_string(self, p):
        '''  
        '''
        _LOGGER.debug("term -> STRING")
        
        p[0] = TypedClass(p[1], TypedClass.STRING)
133988
@SuppressWarnings("unchecked")
    public static MultiValueMap<String, String> getParamsFromQueryString(String queryString) {
        MultiValueMap queryParams = new LinkedMultiValueMap<>();

        if (StringUtils.isNotEmpty(queryString)) {
            String[] params = queryString.split("&");
            for (String param : params) {
                String[] splitParam = param.split("=");
                String paramName = splitParam[0];
                String paramValue = splitParam[1];

                queryParams.add(paramName, paramValue);
            }
        }

        return queryParams;
    }
1369705
public Map<String, String> getGroupNameValueMap(String targetString) {
        return getMatcherAsOpt(targetString)
                .map(matcher -> groupNameList.stream()
                        .collect(Collectors
                                .toMap(Function.identity(), matcher::group)))
                .orElseGet(Collections::emptyMap);
    }
1112948
private List<ImmutableTerm> addToTermsList(String str) {
        ArrayList<ImmutableTerm> terms = new ArrayList<>();
        int i, j;
        String st;
        str = str.substring(1, str.length() - 1);
        while (str.contains("{")) {
            i = getIndexOfCurlyB(str);
            if (i > 0) {
                st = str.substring(0, i);
                st = st.replace("\\\\", "");
                terms.add(termFactory.getConstantLiteral(st));
                str = str.substring(str.indexOf("{", i), str.length());
            } else if (i == 0) {
                j = str.indexOf("}");
                terms.add(termFactory.getVariable(str.substring(1, j)));
                str = str.substring(j + 1, str.length());
            } else {
                break;
            }
        }
        if (!str.equals("")) {
            str = str.replace("\\\\", "");
            terms.add(termFactory.getConstantLiteral(str));
        }
        return terms;
    }
662654
public static List<String> getParameterList(String parameterString) {
        List<String> parameterList = new ArrayList<>();

        StringTokenizer tok = new StringTokenizer(parameterString, ",");
        while (tok.hasMoreElements()) {
            String param = tok.nextToken().trim();
            parameterList.add(cutOffSingleQuotes(param));
        }

        List<String> postProcessed = new ArrayList<>();
        for (int i = 0; i < parameterList.size(); i++) {
            int next = i + 1;

            String processed = parameterList.get(i);

            if (processed.startsWith("'") && !processed.endsWith("'")) {
                while (next < parameterList.size()) {
                    if (parameterString.contains(processed + ", " + parameterList.get(next))) {
                        processed += ", " + parameterList.get(next);
                    } else if (parameterString.contains(processed + "," + parameterList.get(next))) {
                        processed += "," + parameterList.get(next);
                    } else if (parameterString.contains(processed + " , " + parameterList.get(next))) {
                        processed += " , " + parameterList.get(next);
                    } else {
                        processed += parameterList.get(next);
                    }

                    i++;
                    if (parameterList.get(next).endsWith("'")) {
                        break;
                    } else {
                        next++;
                    }
                }

            }

            postProcessed.add(cutOffSingleQuotes(processed));
        }

        return postProcessed;
    }
702394
private int calcCountSubstringsWords(String str, HashSet<String> words) {
    int wordCount = 0;
    int N = str.length();
    for (int i = 0; i < N - 1; i++)
      for (int j = i + 2; j < N + 1; j++) {
        if (words.contains(str.substring(i, j)))
          wordCount += 1;
      }
    return wordCount;
  }
583465
public static Number calStats(String statsString,
            DoubleSummaryStatistics summaryStatistics) {
        return StatsField.valueOfAlias(statsString).calStats(summaryStatistics);
    }
732628
public static ZMsg newStringMsg(String... strings)
    {
        ZMsg msg = new ZMsg();
        for (String data : strings) {
            msg.addString(data);
        }
        return msg;
    }
1018560
private List<String> toListOfStrings(String headerName, List<Object> values) {
        if (values == null) {
            return null;
        }
        List<String> stringValues = new ArrayList<>(values.size());
        HeaderDelegate<Object> hd = HttpUtils.getHeaderDelegate(values.get(0));
        for (Object value : values) {
            String actualValue = hd == null ? value.toString() : hd.toString(value);
            stringValues.add(actualValue);
        }
        return stringValues;
    }
1357442
public List<Tuple> collectTuples(@NonNull HString hString) {
      return streamTuples(hString).collect(Collectors.toList());
   }