/// <summary> /// Creates a new instance of the <see cref="ReferenceDictionary{TKey, TValue}"/> class. /// </summary> /// <param name="initialCapacity">The initial capacity of the dictionary.</param> public ReferenceDictionary(int initialCapacity = DEFAULT_INITIAL_CAPACITY) { if (initialCapacity < 0) { throw new ArgumentOutOfRangeException(nameof(initialCapacity)); } m_slots = new Slot[DataStructureUtil.nextPrime(initialCapacity)]; m_chains = new int[m_slots.Length]; m_chains.AsSpan().Fill(-1); }
/// <summary> /// Adds an element to the array. /// </summary> /// <param name="item">The element to add.</param> public void add(T item) { if (m_array == null) { _setCapacityInternal(4); } else if (m_array.Length == m_length) { int newCapacity = DataStructureUtil.getNextArraySize(m_length, m_length + 1); _setCapacityInternal(newCapacity); } m_array ![m_length++] = item;
/// <summary> /// Encodes a string for use as a URI. Any character other than a letter, number or a /// character in the whitelist will be percent-encoded as UTF-8. /// </summary> /// /// <param name="uri">The string to encode.</param> /// <param name="noEscapeChars">A string containing characters that are not letters or digits, that /// should not be escaped. If this is the empty string, all characters except letters and digits will be /// escaped. Only characters in the ASCII range (0-127) are checked against this string; /// characters outside this range are always escaped.</param> /// <param name="failOnInvalidSurrogate">If this is true, encoding fails if an invalid surrogate /// character is detected. Otherwise, invalid surrogates are replaced by '?' in the encoded /// string.</param> /// <param name="encodedURI">The encoded URI string.</param> /// /// <returns>True if the URI was encoded successfully, false if it is invalid.</returns> public static bool tryEncode( string uri, string noEscapeChars, bool failOnInvalidSurrogate, [NotNullWhen(true)] out string?encodedURI) { if (uri == null) { encodedURI = null; return(false); } char[] buffer = new char[uri.Length]; int bufPos = 0, bufLen = 0; bool error = false; for (int i = 0; i < uri.Length; i++) { char ch = uri[i]; bool noEscape = ((uint)(ch - '0') <= 9) || ((uint)(ch - 'A') <= 25) || ((uint)(ch - 'a') <= 25) || (ch <= 0x7F && noEscapeChars.Contains(ch)); if (bufPos == bufLen) { DataStructureUtil.expandArray(ref buffer); bufLen = buffer.Length; } if (noEscape) { // No percent encoding buffer[bufPos++] = ch; continue; } uint bytes = 0; bool invalidSurrogate = false; if ((uint)(ch - 0xD800) < 0x400) { // Check surrogate pairs if (i == uri.Length - 1) { invalidSurrogate = true; } else { char trail = uri[i + 1]; if ((uint)(trail - 0xDC00) < 0x400) { bytes = _getUTF8Bytes(ch, trail); i++; } else { invalidSurrogate = true; } } } else if ((uint)(ch - 0xDC00) < 0x400) { invalidSurrogate = true; } else { bytes = _getUTF8Bytes(ch); } if (invalidSurrogate) { if (failOnInvalidSurrogate) { error = true; break; } buffer[bufPos++] = '?'; continue; } do { // Write the percent encoding for each byte if (bufLen - bufPos < 3) { DataStructureUtil.expandArray(ref buffer, 3); bufLen = buffer.Length; } buffer[bufPos] = '%'; byteToHex((byte)bytes, buffer.AsSpan(bufPos + 1)); bufPos += 3; bytes >>= 8; } while (bytes != 0); } if (error) { encodedURI = null; return(false); } encodedURI = new string(buffer, 0, bufPos); return(true); }