Creates and returns a string representation of this object,
using the given separator for the fields

@return A String representation of this object
193364
private String createString(String f)
    {
        return
            "srcArray="+srcArray+f+
            "srcPos="+srcPos+f+
            "srcPtr="+srcPtr+f+
            "srcDevice="+srcDevice+f+
            "dstArray="+dstArray+f+
            "dstPos="+dstPos+f+
            "dstPtr="+dstPtr+f+
            "dstDevice="+dstDevice+f+
            "extent="+extent;
    }
862298
public String flattenToString() {
        StringBuilder sb = new StringBuilder(32);
        // WARNING: Do not change the format of this string, it must be
        // preserved because Rects are saved in this flattened format.
        sb.append(left);
        sb.append(' ');
        sb.append(top);
        sb.append(' ');
        sb.append(right);
        sb.append(' ');
        sb.append(bottom);
        return sb.toString();
    }
965950
public static String getName(String s, String separator) {
        if (s.length() == 1) { // handle common case
            return getName(s.charAt(0));
        }
        int cp;
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < s.length(); i += Character.charCount(cp)) {
            cp = s.codePointAt(i);
            if (i != 0) sb.append(separator);
            sb.append(UCharacter.getName(cp));
        }
        return sb.toString();
    }
1296319
public String toXML()
    {
        String eol = SystemUtils.LINE_SEPARATOR;
        StringBuffer buf = new StringBuffer();

        // write all ClassDescriptors
        Iterator i = this.iterator();
        while (i.hasNext())
        {
            buf.append(((XmlCapable) i.next()).toXML() + eol);
        }
        return buf.toString();
    }
665492
public String serialize() {
    StringBuilder sb = new StringBuilder();
    boolean first = true;
    for (String key : options.keySet()) {
      if (first) {
        first = false;
      } else {
        sb.append(';');
      }
      sb.append(key).append('=').append(options.get(key));
    }
    return sb.toString();
  }
541719
public String getValuesAsString() {
		StringBuilder builder = new StringBuilder();
		for(E row: rowKeys.keySet())
			for(E col: colKeys.keySet()) {
				builder.append(getValueAsString(row, col, true));
				builder.append('\n');
			}
		return builder.toString();
	}
639875
public static String toJsonAsString() {
        logger.entering();
        Gson gson = new GsonBuilder().setPrettyPrinting().create();
        JsonObject configItem = new JsonObject();
        for (Entry<String, Map<String, String>> entry : ReporterConfigMetadata.getReporterMetaData().entrySet()) {
            Map<String, String> subMap = entry.getValue();
            for (Entry<String, String> subEntry : subMap.entrySet()) {
                JsonObject configSubItem = new JsonObject();
                configSubItem.addProperty(subEntry.getKey(), subEntry.getValue());
                configItem.add(entry.getKey(), configSubItem);
            }
        }

        String json = gson.toJson(configItem);
        logger.exiting(json);
        return json;
    }
483513
public String toStringByValue() {
	IntArrayList theKeys = new IntArrayList();
	keysSortedByValue(theKeys);

	StringBuffer buf = new StringBuffer();
	buf.append("[");
	int maxIndex = theKeys.size() - 1;
	for (int i = 0; i <= maxIndex; i++) {
		int key = theKeys.get(i);
	    buf.append(String.valueOf(key));
		buf.append("->");
	    buf.append(String.valueOf(get(key)));
		if (i < maxIndex) buf.append(", ");
	}
	buf.append("]");
	return buf.toString();
}
1313918
public String toQueryString() {
		final StringBuffer buf = new StringBuffer();
		final Object value1 = this.values.get(0);
		buf.append(this.column.getName());
		switch (this.type) {
		case STARTS_WIDTH:
			buf.append(" like '" + value1 + "%'");
			break;
		case CONTAINS:
			buf.append(" like '%" + value1 + "%'");
			break;
		case ENDS_WITH:
			buf.append(" like '%" + value1 + "'");
			break;
		case DOESNOT_CONTAINS:
			buf.append(" not like '%" + value1 + "%'");
			break;
		case MORE_THAN:
			buf.append(" > '" + value1 + "'");
			break;
		case LESS_THAN:
			buf.append(" < '" + value1 + "'");
			break;
		}
		return buf.toString();
	}
685564
public String asString() {
    final StringBuilder builder = new StringBuilder();
    boolean first = true;
    for (int i = 1; i < this.nodeList.size(); i++) {
      final NodeImpl nodeImpl = (NodeImpl) this.nodeList.get(i);
      final String name = nodeImpl.asString();
      if (name.isEmpty()) {
        // skip the node if it does not contribute to the string representation of the path, eg
        // class level constraints
        continue;
      }

      if (!first) {
        builder.append(PROPERTY_PATH_SEPARATOR);
      }

      builder.append(nodeImpl.asString());

      first = false;
    }
    return builder.toString();
  }
571782
public static String join(List<String> parts, String separator) {
		Iterator<String> it = parts.iterator();
		StringBuilder builder = new StringBuilder();
		while (it.hasNext()) {
			String part = it.next();
			builder.append(part);
			if (it.hasNext()) {
				builder.append(separator);
			}
		}
		return builder.toString();
	}
162241
public static String format( Collection<String> items, String separator ) {

		StringBuilder sb = new StringBuilder();
		for( Iterator<String> it = items.iterator(); it.hasNext(); ) {
			sb.append( it.next());
			if( it.hasNext())
				sb.append( separator );
		}

		return sb.toString();
	}
609021
public String nextString()
    {
        char[] buffer = new char[nextInt()];
        for (int i = 0; i < buffer.length; ++i)
        {
            buffer[i] = nextChar();
        }
        return new String(buffer);
    }
849427
protected String getStringValue(){
		if(type==VALUE_NULL){
			return null;
		}else if(!(type==VALUE_ESTRING||type==EFIELD)){
			if(dirty){
				return dirtyBuf.substring(startIndex,endIndex);
			}
			return new String(cbuf,startIndex,endIndex-startIndex);
		}else{
			StringBuilder buf=new StringBuilder(endIndex-startIndex);
			if(dirty){
				for(int i=startIndex;i<endIndex;i++){
					char c=dirtyBuf.charAt(i);
					if(c=='\\'){
						i++;
						c=dirtyBuf.charAt(i);
						if(c=='"' || c=='\\' || c=='/'){
							buf.append(c);
						}else if(c=='b'){
							buf.append('\b');
						}else if(c=='f'){
							buf.append('\f');
						}else if(c=='n'){
							buf.append('\n');
						}else if(c=='r'){
							buf.append('\r');
						}else if(c=='t'){
							buf.append('\t');
						}else if(c=='u'){
							String code=dirtyBuf.substring(i+1,i+5);
							buf.append((char)Integer.parseInt(code, 16));
							i+=4;
						}
					}else{
						buf.append(c);
					}
				}
			}else{
				for(int i=startIndex;i<endIndex;i++){
					char c=cbuf[i];
					if(c=='\\'){
						i++;
						c=cbuf[i];
						if(c=='"' || c=='\\' || c=='/'){
							buf.append(c);
						}else if(c=='b'){
							buf.append('\b');
						}else if(c=='f'){
							buf.append('\f');
						}else if(c=='n'){
							buf.append('\n');
						}else if(c=='r'){
							buf.append('\r');
						}else if(c=='t'){
							buf.append('\t');
						}else if(c=='u'){
							String code=new String(cbuf,i+1,4);
							buf.append((char)Integer.parseInt(code, 16));
							i+=4;
						}
					}else{
						buf.append(c);
					}
				}
			}
			return buf.toString();
		}
	}
901390
public String getEscapedFieldDelimiter() {
        final String escaped;

        switch (fieldDelimiter) {
            case ';':
                escaped = "\\semi";
                break;

            case '\'':
                escaped = "\\quote";
                break;

            case ' ':
                escaped = "\\space";
                break;

            case '`':
                escaped = "\\apos";
                break;

            default:
                escaped = String.valueOf(fieldDelimiter);
        }

        return escaped;
    }
1113116
public static String field(EvaluationContext ctx, Object text, Object index, @StringDefault(" ") Object delimiter) {
        String _text = Conversions.toString(text, ctx);
        int _index = Conversions.toInteger(index, ctx);
        String _delimiter = Conversions.toString(delimiter, ctx);

        String[] splits = StringUtils.splitByWholeSeparator(_text, _delimiter);

        if (_index < 1) {
            throw new RuntimeException("Field index cannot be less than 1");
        }

        if (_index <= splits.length) {
            return splits[_index - 1];
        } else {
            return "";
        }
    }
926794
public StringBuilder contentsAsStringBuilder(int extraSpace)
    {
        if (mResultString != null) {
            return new StringBuilder(mResultString);
        }
        if (mResultArray != null) {
            StringBuilder sb = new StringBuilder(mResultArray.length + extraSpace);
            sb.append(mResultArray, 0, mResultArray.length);
            return sb;
        }
        if (mInputStart >= 0) { // shared array
            if (mInputLen < 1) {
                return new StringBuilder();
            }
            StringBuilder sb = new StringBuilder(mInputLen + extraSpace);
            sb.append(mInputBuffer, mInputStart, mInputLen);
            return sb;
        }
        int segLen = mSegmentSize;
        int currLen = mCurrentSize;

        StringBuilder sb = new StringBuilder(segLen + currLen + extraSpace);
        // First stored segments
        if (mSegments != null) {
            for (int i = 0, len = mSegments.size(); i < len; ++i) {
                char[] curr = mSegments.get(i);
                sb.append(curr, 0, curr.length);
            }
        }
        // And finally, current segment:
        sb.append(mCurrentSegment, 0, currLen);
        return sb;
    }