Create a new {@link Colonies} instance that uses the given character agent to
make its HTTP requests to the ESI interface.

@param char The character access information
@returns An Colonies API instance
335182
function makeColonies(char) {
    return function (id) {
        if (id === undefined) {
            return char.agent.request('get_characters_character_id_planets', { path: { character_id: char.id } }, char.ssoToken);
        }
        else {
            return new ColonyImpl(char, id);
        }
    };
}
1189541
@Override
    public void characters(char ch[], int start, int length) {
	content.append(new String(ch, start, length));
    }
613405
public static StrMatcher charSetMatcher(final String chars) {
        if (StringUtils.isEmpty(chars)) {
            return NONE_MATCHER;
        }
        if (chars.length() == 1) {
            return new CharMatcher(chars.charAt(0));
        }
        return new CharSetMatcher(chars.toCharArray());
    }
1082646
public CharacterInfo getCharacterInfo() throws ApiException {
        return new CharacterInfo(metaApi.getVerify(null, null, DATASOURCE, null, null));
    }
831297
protected KeyBucket makeBucket(char c) {
        if (c > this.buckets.length) {
            // can't handle non-ASCII chars
            return null;
        }
        int index = c;
        // if we're case-insensitive, push uppercase into lowercase buckets
        if (!isCaseSensitive() && (c >= 'A' && c <= 'Z')) {
            index += 32;
        }
        if (null == this.buckets[index]) {
            this.buckets[index] = new KeyBucket();
        }
        return this.buckets[index];
    }
1317749
public Packet putChar(char c, ByteOrder order) {
        var buffer = HEAP_BUFFER_POOL.take(Character.BYTES);
        var array = buffer.putChar(order == ByteOrder.LITTLE_ENDIAN ? Character.reverseBytes(c) : c).array();
        
        try {
            return enqueue(Arrays.copyOfRange(array, 0, Character.BYTES));
        } finally {
            HEAP_BUFFER_POOL.give(buffer);
        }
    }
171153
public Agent newAgent(Agent a) {
	Agent res = newAgent(a.getId());
	res.getType().addAll(a.getType());
	res.getLabel().addAll(a.getLabel());
	return res;
    }
270088
public static byte[] chars2Bytes(final char[] chars) {
        if (chars == null || chars.length <= 0) return null;
        int    len   = chars.length;
        byte[] bytes = new byte[len];
        for (int i = 0; i < len; i++) {
            bytes[i] = (byte) (chars[i]);
        }
        return bytes;
    }
534862
static CharOutput stringBuilderOutput(int initialSize) {
    final StringBuilder builder = new StringBuilder(initialSize);
    return new CharOutput() {

      @Override
      public void write(char c) {
        builder.append(c);
      }

      @Override
      public void flush() {}

      @Override
      public void close() {}

      @Override
      public String toString() {
        return builder.toString();
      }
    };
  }
839278
public void add(Character character) {
    elements.add(character == null ? JsonNull.INSTANCE : new JsonPrimitive(character));
  }
855108
@SuppressWarnings("deprecation")
    @Override
    public void characters(char[] ch, int start, int length)
            throws SAXException {
        if (alreadyComplainedAboutThisRun) {
            return;
        }
        if (atStartOfRun) {
            char c = ch[start];
            if (pos == 1) {
                // there's a single high surrogate in buf
                if (isComposingChar(UCharacter.getCodePoint(buf[0], c))) {
                    warn("Text run starts with a composing character.");
                }
                atStartOfRun = false;
            } else {
                if (length == 1 && UCharacter.isHighSurrogate(c)) {
                    buf[0] = c;
                    pos = 1;
                    return;
                } else {
                    if (UCharacter.isHighSurrogate(c)) {
                        if (isComposingChar(UCharacter.getCodePoint(c,
                                ch[start + 1]))) {
                            warn("Text run starts with a composing character.");
                        }
                    } else {
                        if (isComposingCharOrSurrogate(c)) {
                            warn("Text run starts with a composing character.");
                        }
                    }
                    atStartOfRun = false;
                }
            }
        }
        int i = start;
        int stop = start + length;
        if (pos > 0) {
            // there's stuff in buf
            while (i < stop && isComposingCharOrSurrogate(ch[i])) {
                i++;
            }
            appendToBuf(ch, start, i);
            if (i == stop) {
                return;
            } else {
                if (!Normalizer.isNormalized(buf, 0, pos, Normalizer.NFC, 0)) {
                    errAboutTextRun();
                }
                pos = 0;
            }
        }
        if (i < stop) {
            start = i;
            i = stop - 1;
            while (i > start && isComposingCharOrSurrogate(ch[i])) {
                i--;
            }
            if (i > start
                    && !Normalizer.isNormalized(ch, start, i, Normalizer.NFC, 0)) {
                errAboutTextRun();
            }
            appendToBuf(ch, i, stop);
        }
    }
892325
function makeCharacters(agent) {
    let characters = function (id, ssoToken) {
        if (ssoToken === undefined) {
            return new CharacterInfoImpl(agent, id);
        }
        else {
            return new CharacterImpl({ agent, id, ssoToken });
        }
    };
    characters.search = search_1.makeDefaultSearch(agent, "character" /* CHARACTER */);
    characters.affiliations = function (ids) {
        return agent.request('post_characters_affiliation', { body: ids });
    };
    characters.names = function (ids) {
        if (ids.length > 100) {
            // Use universe/names end point since the /characters one breaks if
            // the URL gets too long.
            return names_1.getNames(agent, "character" /* CHARACTER */, ids);
        }
        else {
            // Use character/names end point
            return agent.request('get_characters_names', { query: { character_ids: ids } })
                .then(result => {
                let map = new Map();
                for (let c of result) {
                    map.set(c.character_id, c.character_name);
                }
                return map;
            });
        }
    };
    return characters;
}
47341
public static Characters of(String chars) {
        return StringUtils.isEmpty(chars) ? Characters.NONE : new Characters(false, chars.toCharArray());
    }
678230
private TrieNode getRootNodeIfNotExistThenCreate(char character){
        TrieNode trieNode = getRootNode(character);
        if(trieNode == null){
            trieNode = new TrieNode(character);
            addRootNode(trieNode);
        }
        return trieNode;
    }
913524
public static Character getPropertyCharacter(Class<?> aClass, String key,
			char defaultValue)
	{
		return getSettings().getPropertyCharacter(aClass, key, defaultValue);

	}
1366211
function (char) {
                if (this._handleEntities(char)) {
                    return;
                }
                if ("*" === char) {
                    return this._parseItalic;
                } else if ("`" === char) {
                    this._toggleTag("code");
                    return this._parseMonospace;
                } else if ("[" === char) {
                    return this._startLink(0);
                } else if ("!" === char) {
                    return this._parseImage;
                } else if ("-" === char) {
                    this._escapeCount = 1;
                    this._escapeChar = "-";
                    return this._parseEscape;
                } else if ("\n" === char) {
                    return null;
                } else {
                    this._output(char);
                }
            }
979871
public void characters(String characters) throws SAXException
    {
        final int len = characters.length();
        if (len > m_charsBuff.length)
        {
           m_charsBuff = new char[len*2 + 1];             
        }
        characters.getChars(0,len, m_charsBuff, 0);   
        characters(m_charsBuff, 0, len);
    }