Return this expression as a string that can be placed in the template as a replacement of the
Java expression.

@return An expression that can be interpreted by Vue.js
429088
public String toTemplateString() {
    String[] parametersName =
        this.parameters.stream().map(VariableInfo::getName).toArray(String[]::new);

    return this.getId() + "(" + String.join(", ", parametersName) + ")";
  }
1150268
public java.lang.String getFor() {
        return (java.lang.String) getStateHelper().eval(PropertyKeys.forVal);

    }
397707
public String getString(String expression) {
		return (String) evalXPath(expression, null, XPathConstants.STRING);
	}
623004
function () {
                var e, t, c, v;

                c = $(this.combinator);

                e = $(/^(?:\d+\.\d+|\d+)%/) || $(/^(?:[.#]?|:*)(?:[\w-]|[^\x00-\x9f]|\\(?:[A-Fa-f0-9]{1,6} ?|[^A-Fa-f0-9]))+/) ||
                    $('*') || $('&') || $(this.attribute) || $(/^\([^)@]+\)/) || $(/^[\.#](?=@)/) || $(this.entities.variableCurly);

                if (! e) {
                    if ($('(') && (v = ($(this.entities.variableCurly) || $(this.entities.variable))) && $(')')) {
                        e = new(tree.Paren)(v);
                    }
                }

                if (e) { return new(tree.Element)(c, e, i) }
            }
305701
public Expression getFromExpression() {
        if (_fromExpression == null && _from != null) {
            _fromExpression = ExpressionFactory.INSTANCE.create(_from, null, _propertyResolver);
        }
        return _fromExpression;
    }
1109595
public function asJavascript()
    {
        return implode("\n    ", array_map(function ($push) {
            return '_paq.push([' . implode(', ', array_map(function ($item) {
                    if ($item instanceof RawExpression) {
                        return $item->value;
                    }

                    // JSON encoding is used to escape data injected into javascript
                    return json_encode($item);
                }, $push)) . ']);';
        }, $this->pushs));
    }
688104
private String[] splitVForExpression(String vForValue, TemplateParserContext context) {
    String[] splitExpression = vForValue.split(" in ");
    if (splitExpression.length != 2) {
      splitExpression = vForValue.split(" of ");
    }

    if (splitExpression.length != 2) {
      logger.error("Invalid v-for found, they should be in the form: \"Todo todo in myTodos\"",
          vForValue);
    }

    return splitExpression;
  }
682333
public StringExpression trim() {
        if (trim == null) {
            trim = Expressions.stringOperation(Ops.TRIM, mixin);
        }
        return trim;
    }
656552
private function t($v)
    {
        if (null === $this->translationFile) {
            // no translation file, use original
            $translatedText = $v;
        } else {
            /** @psalm-suppress UnresolvableInclude */
            $translationData = include $this->translationFile;
            if (\array_key_exists($v, $translationData)) {
                // translation found
                $translatedText = $translationData[$v];
            } else {
                // not found, use original
                $translatedText = $v;
            }
        }

        // find all string values, wrap the key, and escape the variable
        $escapedVars = [];
        foreach ($this->templateVariables as $k => $v) {
            if (\is_string($v)) {
                $escapedVars['%'.$k.'%'] = $this->e($v);
            }
        }

        return str_replace(array_keys($escapedVars), array_values($escapedVars), $translatedText);
    }
652714
function() {
            var tpl = this.options.template;

            //first pass
            $.each(this.map, function(k, v) {
                v = v[0]; 
                var r = new RegExp(v+'+'),
                    token = v.length > 1 ? v.substring(1, 2) : v;
                    
                tpl = tpl.replace(r, '{'+token+'}');
            });

            //replace spaces with &nbsp;
            tpl = tpl.replace(/ /g, '&nbsp;');

            //second pass
            $.each(this.map, function(k, v) {
                v = v[0];
                var token = v.length > 1 ? v.substring(1, 2) : v;
                    
                tpl = tpl.replace('{'+token+'}', '<select class="'+k+'"></select>');
            });   

            return tpl;
        }
1229573
public StringExpression stringValue() {
        if (stringCast == null) {
            stringCast = Expressions.stringOperation(Ops.STRING_CAST, mixin);
        }
        return stringCast;
    }
341637
private static String format(String template, @javax.annotation.Nullable Object... args) {
    // If no arguments return the template.
    if (args == null) {
      return template;
    }

    // start substituting the arguments into the '%s' placeholders
    StringBuilder builder = new StringBuilder(template.length() + 16 * args.length);
    int templateStart = 0;
    int i = 0;
    while (i < args.length) {
      int placeholderStart = template.indexOf("%s", templateStart);
      if (placeholderStart == -1) {
        break;
      }
      builder.append(template, templateStart, placeholderStart);
      builder.append(args[i++]);
      templateStart = placeholderStart + 2;
    }
    builder.append(template, templateStart, template.length());

    // if we run out of placeholders, append the extra args in square braces
    if (i < args.length) {
      builder.append(" [");
      builder.append(args[i++]);
      while (i < args.length) {
        builder.append(", ");
        builder.append(args[i++]);
      }
      builder.append(']');
    }

    return builder.toString();
  }
75528
function() {
    var node = this.expression();

    while (this.accept(',')) {
      if (node.isList) {
        list.push(this.expression());
      } else {
        var list = new nodes.Expression(true);
        list.push(node);
        list.push(this.expression());
        node = list;
      }
    }
    return node;
  }
8471
protected String getExpressionTextForLanguage(DmnExpressionImpl expression, String expressionLanguage) {
    String expressionText = expression.getExpression();
    if (expressionText != null) {
      if (isJuelExpression(expressionLanguage) && !StringUtil.isExpression(expressionText)) {
        return "${" + expressionText + "}";
      } else {
        return expressionText;
      }
    } else {
      return null;
    }
  }
1106156
public static StringExpression asString(Expression<String> expr) {
        Expression<String> underlyingMixin = ExpressionUtils.extract(expr);
        if (underlyingMixin instanceof PathImpl) {
            return new StringPath((PathImpl<String>) underlyingMixin);
        } else if (underlyingMixin instanceof OperationImpl) {
            return new StringOperation((OperationImpl<String>) underlyingMixin);
        } else if (underlyingMixin instanceof TemplateExpressionImpl) {
            return new StringTemplate((TemplateExpressionImpl<String>) underlyingMixin);
        } else {
            return new StringExpression(underlyingMixin) {

                private static final long serialVersionUID = 8007203530480765244L;

                @Override
                public <R, C> R accept(Visitor<R, C> v, C context) {
                    return this.mixin.accept(v, context);
                }

            };
        }
    }
777165
private String getFieldTemplate() {

        if (m_fieldKeepTemplate.getValue().booleanValue()) {
            return ""; //No template property will be changed
        }
        Object value = m_simpleFieldTemplate.getValue();
        if (value != null) {
            return (String)value;
        }
        return "";
    }
1305649
@Override
	public String getValueAsString() {
		String result = null;

		String[] inputs = getValue();

		if (inputs != null && inputs.length > 0) {
			StringBuffer stringValues = new StringBuffer();

			for (int i = 0; i < inputs.length; i++) {
				if (i > 0) {
					stringValues.append(", ");
				}

				stringValues.append(inputs[i]);
			}

			result = stringValues.toString();

		}

		return result;
	}