Select desired delimeter
        
        Args:
            delim: The delimeter character you want.
        Returns:
            None
        Raises:
            RuntimeError: Delimeter too long.
331685
def select_delim(self, delim):
        '''
        '''
        size = len(delim)
        if size > 20:
            raise RuntimeError('Delimeter too long')
        n1 = size/10
        n2 = size%10
        self.send('^SS'+chr(n1)+chr(n2))
463024
public static String asString(final Object[] input, final String delim) {
        final StringBuffer sb = new StringBuffer();
        for (int i = 0 ; i < input.length ; i++) {
            if (i > 0) {
                sb.append(delim);
            }
            sb.append(input[i].toString());
        }
        return sb.toString();
    }
560948
def _todict(expr, item_delim=',', kv_delim='='):
    
    return _string_op(expr, StringToDict, _item_delim=item_delim, _kv_delim=kv_delim,
                      output_type=types.Dict(types.string, types.string))
1236549
public List<Long> getLongs(String name, String delimiter) {
        List<String> strings = getStrings(name, delimiter);

        List<Long> longs = new ArrayList<>(strings.size());
        for (String value : strings) {
            try {
                long i = Long.parseLong(value);
                longs.add(i);
            } catch (NumberFormatException e) {
            }
        }

        return Collections.unmodifiableList(longs);
    }
1268288
def delim(arguments):
    

    if bool(arguments.control_files) == bool(arguments.directory):
        raise ValueError(
                'Exactly one of control_files and `-d` must be specified.')

    if arguments.directory:
        arguments.control_files.extend(control_iter(arguments.directory))

    with arguments.output as fp:
        results = _delim_accum(arguments.control_files,
                arguments.file_template, arguments.keys,
                arguments.exclude_keys, arguments.separator,
                missing_action=arguments.missing_action)
        r = next(results)
        writer = csv.DictWriter(fp, r.keys(), delimiter=arguments.separator)
        writer.writeheader()
        writer.writerow(r)
        writer.writerows(results)
650900
def long2str(l):
    """"""
    if type(l) not in (types.IntType, types.LongType):
        raise ValueError('the input must be an integer')

    if l < 0:
        raise ValueError('the input must be greater than 0')
    s = ''
    while l:
        s = s + chr(l & 255)
        l >>= 8

    return s
240445
def check_length(value, length):
    
    _length = len(value)
    if _length != length:
        raise ValueError("length must be %d, not %d" % \
                         (length, _length))
374587
def _choose_width_fn(has_invisible, enable_widechars, is_multiline):
    """"""
    if has_invisible:
        line_width_fn = _visible_width
    elif enable_widechars:  # optional wide-character support if available
        line_width_fn = wcwidth.wcswidth
    else:
        line_width_fn = len
    if is_multiline:
        def width_fn(s): return _multiline_width(s, line_width_fn)
    else:
        width_fn = line_width_fn
    return width_fn
1178772
public static int lastIndexOf(final String input, final char delim) {
        return input == null ? -1 : lastIndexOf(input, delim, input.length());
    }
1118258
function delimsObject(delims) {
  var a = delims[0], b = delims[1];
  var res = {};
  res.interpolate = lazy.delimiters(a + '=', b);
  res.evaluate = lazy.delimiters(a, b);
  res.escape = lazy.delimiters(a + '-', b);
  return res;
}
187495
private void require(String delim) throws SAXException, IOException {
        int length = delim.length();
        char[] ch;

        if (length < dataBuffer.length) {
            ch = dataBuffer;
            delim.getChars(0, length, ch, 0);
        } else {
            ch = delim.toCharArray();
        }

        for (int i = 0; i < length; i++) {
                require(ch[i]);
        }
    }
1334092
public final void mDELIMITER() throws RecognitionException {
		try {
			int _type = DELIMITER;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// druidG.g:590:17: ( ( 'DELIMITER' | 'delimiter' ) )
			// druidG.g:590:18: ( 'DELIMITER' | 'delimiter' )
			{
			// druidG.g:590:18: ( 'DELIMITER' | 'delimiter' )
			int alt7=2;
			int LA7_0 = input.LA(1);
			if ( (LA7_0=='D') ) {
				alt7=1;
			}
			else if ( (LA7_0=='d') ) {
				alt7=2;
			}

			else {
				NoViableAltException nvae =
					new NoViableAltException("", 7, 0, input);
				throw nvae;
			}

			switch (alt7) {
				case 1 :
					// druidG.g:590:19: 'DELIMITER'
					{
					match("DELIMITER"); 

					}
					break;
				case 2 :
					// druidG.g:590:31: 'delimiter'
					{
					match("delimiter"); 

					}
					break;

			}

			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
539037
private static Configuration overrideDelimiter(Configuration configuration) {
        configuration.setBoolean(TcpTransport.CK_USE_NULL_DELIMITER, true);

        return configuration;
    }
820829
public static int getDelimIndex(StringBuilder sb, int itemPos, char[] delims, boolean ignoreEmpty) {

	if (StringUtil.isEmpty(sb)) return -1;

	int curr = -1, listIndex = 0;
	int len = sb.length();
	for (int i = 0; i < len; i++) {
	    if (contains(delims, sb.charAt(i))) {
		curr = i;
		if (ignoreEmpty) {
		    if (i == 0 || (i + 1 < len && contains(delims, sb.charAt(i + 1)))) {
			sb.delete(curr, curr + 1);
			len--;
			i--;
			curr--;
			continue;
		    }
		}
		if (++listIndex == itemPos) break;
	    }
	}
	if (listIndex < itemPos) return len;
	return curr;
    }
541444
def getLong(t):
    
    i = c_long()
    if PL_get_long(t, byref(i)):
        return i.value
    else:
        raise InvalidTypeError("long")
1109
def read_str(delim=',', *lines):
    """"""

    data = []
    for line in lines:
        com = parse_line(line, delim)
        data.append(com)
    return data
1356470
private int getNextDelimiter(int offset)
    {
        if (offset >= 0) {
            int result = offset; 
            int c = 0;
            if (delims == null) {
                do {
                    c = UTF16.charAt(m_source_, result);
                    if (m_delimiters_.contains(c)) {
                        break;
                    }
                    result ++;
                } while (result < m_length_);
            } else {
                do {
                    c = UTF16.charAt(m_source_, result);
                    if (c < delims.length && delims[c]) {
                        break;
                    }
                    result ++;
                } while (result < m_length_);
            }                
            if (result < m_length_) {
                return result;
            }
        }
        return -1 - m_length_;
    }