/// <summary>
/// Creates a new instance of <see cref="PooledIntegerSet"/>.
/// </summary>
/// <param name="pool">A <see cref="DynamicArrayPool{Int32}"/> instance from which the memory
/// for this set should be allocated.</param>
/// <param name="capacity">The initial capacity to allocate for this set.</param>
public PooledIntegerSet(DynamicArrayPool <int> pool, int capacity = 0)
{
m_pool = pool;
m_token = pool.allocate((capacity > 0) ? DataStructureUtil.nextPowerOf2(capacity - 1) : 4);
m_pool.getSpan(m_token).Fill(EMPTY_SLOT);
m_count = 0;
}
public void nextPrimeTest(int num)
{
int nextPrime = DataStructureUtil.nextPrime(num);
Assert.True(nextPrime > 1, $"Expected {nextPrime} to be > 1.");
Assert.True(nextPrime >= num, $"Expected {nextPrime} to be >= {num}.");
for (int i = 2; (long)i * i <= (long)nextPrime; i++)
{
Assert.True(nextPrime % i != 0, $"Expected {nextPrime} to be prime, but has has factor {i}.");
}
}
public void nextPowerOf2Test(int num)
{
int nextPowerOf2 = DataStructureUtil.nextPowerOf2(num);
Assert.NotEqual(0, nextPowerOf2);
Assert.True((nextPowerOf2 & (nextPowerOf2 - 1)) == 0, $"Expected {nextPowerOf2} to be a power of 2.");
Assert.True(nextPowerOf2 >= num, $"Expected {nextPowerOf2} to be >= {num}");
uint upperBound = (uint)Math.Max(num, 1) * 2;
Assert.True((uint)nextPowerOf2 < upperBound, $"Expected {nextPowerOf2} to be < {upperBound}.");
}
/// <summary>
/// Setup cross sectional DSD.
/// </summary>
/// <param name="parent">
/// The parent.
/// </param>
/// <param name="crossDataSet">
/// The list of components attached to cross-sectional data set.
/// </param>
/// <param name="crossGroup">
/// The list of components attached to cross-sectional group.
/// </param>
/// <param name="crossSection">
/// The list of components attached to cross-sectional section.
/// </param>
/// <param name="crossObs">
/// The list of components attached to cross-sectional observation level
/// </param>
/// <param name="crossSectionalMeasures">
/// The cross sectional measures.
/// </param>
/// <param name="measureCodelistRepresentation">
/// The SDMX v2.0 measure dimension codelist representation; otherwise null
/// </param>
/// <returns>
/// The <see cref="IDataStructureMutableObject"/>.
/// </returns>
private static IDataStructureMutableObject SetupCrossSectionalDsd(
IDataStructureMutableObject parent,
ICollection <string> crossDataSet,
ICollection <string> crossGroup,
ICollection <string> crossSection,
ICollection <string> crossObs,
IEnumerable <ICrossSectionalMeasureMutableObject> crossSectionalMeasures,
IStructureReference measureCodelistRepresentation)
{
if (
parent.Dimensions.All(
o =>
o.FrequencyDimension || o.TimeDimension || o.MeasureDimension || crossDataSet.Contains(o.Id) || crossGroup.Contains(o.Id) || crossSection.Contains(o.Id) || crossObs.Contains(o.Id)))
{
if (parent.AttributeList == null ||
parent.AttributeList.Attributes.All(o => crossDataSet.Contains(o.Id) || crossGroup.Contains(o.Id) || crossSection.Contains(o.Id) || crossObs.Contains(o.Id)))
{
ICrossSectionalDataStructureMutableObject crossDsd = _crossDsdBuilder.Build(parent);
crossDsd.CrossSectionalAttachDataSet.AddAll(crossDataSet);
crossDsd.CrossSectionalAttachSection.AddAll(crossSection);
crossDsd.CrossSectionalAttachGroup.AddAll(crossGroup);
crossDsd.CrossSectionalAttachObservation.AddAll(crossObs);
IDimensionMutableObject measure = crossDsd.Dimensions.FirstOrDefault(o => o.MeasureDimension);
if (measure != null)
{
foreach (ICrossSectionalMeasureMutableObject crossSectionalMeasureMutableObject in crossSectionalMeasures)
{
crossSectionalMeasureMutableObject.MeasureDimension = measure.Id;
crossDsd.CrossSectionalMeasures.Add(crossSectionalMeasureMutableObject);
}
if (measureCodelistRepresentation == null)
{
DataStructureUtil.ConvertMeasureRepresentation(crossDsd);
}
}
return(crossDsd);
}
}
return(parent);
}
/// <summary>
/// Writes the character or surrogate pair for the given code point into the buffer.
/// </summary>
/// <param name="buffer">The buffer into which to write the character(s). This
/// may be reallocated if there is not enough space.</param>
/// <param name="position">The position in <paramref name="buffer"/> into which to
/// write the character(s). The number of characters written will be added.</param>
/// <param name="value">A Unicode code point value.</param>
private static void _writeCodePoint(ref char[] buffer, ref int position, int value)
{
if (buffer.Length - position < 2)
{
DataStructureUtil.expandArray(ref buffer, 2);
}
if (value > 0xFFFF)
{
// Split into surrogate pairs.
int offsetValue = value - 0x10000;
buffer[position] = (char)(0xD800 | (offsetValue >> 10));
buffer[position + 1] = (char)(0xDC00 | (offsetValue & 0x3FF));
position += 2;
}
else
{
buffer[position] = (char)value;
position++;
}
}
/// <summary>
/// Reads an attribute value and returns it.
/// </summary>
private string _readAttributeValue()
{
char quote = m_str[m_pos];
if (quote != '"' && quote != '\'')
{
throw _error(ErrorCode.XML_PARSER_ELEMENT_MALFORMED);
}
m_pos++;
ReadOnlySpan <char> span = m_str.AsSpan(m_pos);
int charsLeft = m_str.Length - m_pos;
char newline = s_newLineChar;
ReadOnlySpan <char> searchChars = stackalloc char[] { quote, '&', '<', newline };
bool mayHaveEntities = false;
while (true)
{
int index = span.IndexOfAny(searchChars);
if (index == -1)
{
throw _error(ErrorCode.XML_PARSER_UNTERMINATED_ATTR);
}
char charAtIndex = span[index];
if (charAtIndex == quote)
{
span = span.Slice(index);
break;
}
else if (charAtIndex == '&')
{
span = span.Slice(index);
mayHaveEntities = true;
break;
}
else if (charAtIndex == newline)
{
m_curLine++;
span = span.Slice(index + 1);
}
else
{
// Attributes cannot contain '<'.
throw _error(ErrorCode.XML_PARSER_ELEMENT_MALFORMED);
}
}
int charsRead = charsLeft - span.Length;
if (!mayHaveEntities)
{
int startPos = m_pos;
m_pos += charsRead + 1; // +1 for the closing quote
return(m_str.Substring(startPos, charsRead));
}
char[] textBuffer = m_buffer;
if (textBuffer.Length < charsRead)
{
DataStructureUtil.resizeArray(ref textBuffer, textBuffer.Length, charsRead);
}
m_str.CopyTo(m_pos, textBuffer, 0, charsRead);
m_pos += charsRead;
int textBufPos = charsRead;
while (true)
{
char ch = m_str[m_pos];
if (ch == '&')
{
int entityCode = _readEntity();
_writeCodePoint(ref textBuffer, ref textBufPos, entityCode);
}
else if (ch == quote)
{
break;
}
else if (ch == '<')
{
throw _error(ErrorCode.XML_PARSER_ELEMENT_MALFORMED);
}
else if (ch == newline)
{
m_curLine++;
m_pos++;
}
span = m_str.AsSpan(m_pos);
int nextIndex = span.IndexOfAny(searchChars);
if (nextIndex == -1)
{
throw _error(ErrorCode.XML_PARSER_UNTERMINATED_ATTR);
}
if (textBuffer.Length - textBufPos < nextIndex)
{
DataStructureUtil.resizeArray(ref textBuffer, textBufPos, textBufPos + nextIndex);
}
span.Slice(0, nextIndex).CopyTo(textBuffer.AsSpan(textBufPos));
textBufPos += nextIndex;
m_pos += nextIndex;
}
m_pos++; // For closing quote
m_buffer = textBuffer;
return((textBufPos == 0) ? "" : new string(textBuffer, 0, textBufPos));
}
/// <summary>
/// Reads a text node and adds it as a child to the element currently being processed.
/// </summary>
private void _readText()
{
ReadOnlySpan <char> span = m_str.AsSpan(m_pos);
int charsLeft = m_str.Length - m_pos;
char newline = s_newLineChar;
ReadOnlySpan <char> searchChars = stackalloc char[3] {
'<', '&', newline
};
bool mayHaveEntities = false;
while (!span.IsEmpty)
{
int index = span.IndexOfAny(searchChars);
char charAtIndex = (index == -1) ? '\0' : span[index];
if (charAtIndex == '<')
{
span = span.Slice(index);
break;
}
else if (charAtIndex == '&')
{
span = span.Slice(index);
mayHaveEntities = true;
break;
}
else if (charAtIndex == newline)
{
m_curLine++;
span = span.Slice(index + 1);
}
else
{
span = default;
}
}
int charsRead = charsLeft - span.Length;
string text;
if (!mayHaveEntities)
{
text = ((m_parserFlags & FLAG_IGNORE_SPACE) != 0)
? XMLHelper.stripWhitespace(m_str, m_pos, charsRead)
: m_str.Substring(m_pos, charsRead);
if (text.Length != 0)
{
m_nodeStack.add(ASXML.createTextNode(text));
}
m_pos += charsRead;
return;
}
char[] textBuffer = m_buffer;
if (charsRead > textBuffer.Length)
{
DataStructureUtil.resizeArray(ref textBuffer, textBuffer.Length, charsRead);
}
m_str.CopyTo(m_pos, textBuffer, 0, charsRead);
int textBufPos = charsRead;
m_pos += charsRead;
while (true)
{
char ch = m_str[m_pos];
if (ch == '&')
{
int entityCode = _readEntity();
_writeCodePoint(ref textBuffer, ref textBufPos, entityCode);
}
else if (ch == '<')
{
break;
}
else if (ch == newline)
{
m_curLine++;
m_pos++;
}
span = m_str.AsSpan(m_pos);
int nextIndex = span.IndexOfAny(searchChars);
int charsToCopy = (nextIndex == -1) ? span.Length : nextIndex;
if (textBuffer.Length - textBufPos < charsToCopy)
{
DataStructureUtil.resizeArray(ref textBuffer, textBufPos, textBufPos + charsToCopy);
}
span.Slice(0, charsToCopy).CopyTo(textBuffer.AsSpan(textBufPos));
textBufPos += charsToCopy;
m_pos += charsToCopy;
if (nextIndex == -1)
{
break;
}
}
m_buffer = textBuffer;
if (textBufPos == 0)
{
return;
}
text = ((m_parserFlags & FLAG_IGNORE_SPACE) != 0)
? XMLHelper.stripWhitespace(textBuffer, 0, textBufPos)
: new string(textBuffer, 0, textBufPos);
if (text.Length != 0)
{
m_nodeStack.add(ASXML.createTextNode(text));
}
}
public static string escape(string str = "undefined")
{
if (str == null)
{
return("null");
}
int strlen = str.Length;
char[] buffer = new char[strlen];
int bufPos = 0, bufLen = 0;
for (int i = 0; i < str.Length; i++)
{
char ch = str[i];
bool noEncode =
((uint)(ch - '0') <= 9) ||
((uint)(ch - 'A') <= 25) ||
((uint)(ch - 'a') <= 25) ||
(ch <= 0x7F && ESCAPE_NO_ENCODE.Contains(ch));
if (noEncode)
{
// No percent encoding
if (bufPos == bufLen)
{
DataStructureUtil.expandArray(ref buffer);
bufLen = buffer.Length;
}
buffer[bufPos++] = ch;
continue;
}
if (ch > 0xFF)
{
if (bufLen - bufPos < 6)
{
DataStructureUtil.expandArray(ref buffer, 6);
bufLen = buffer.Length;
}
var bufferSpan = buffer.AsSpan(6);
bufferSpan[0] = '%';
bufferSpan[1] = 'u';
URIUtil.byteToHex((byte)(ch >> 8), bufferSpan.Slice(2));
URIUtil.byteToHex((byte)ch, bufferSpan.Slice(4));
bufPos += 6;
}
else
{
if (bufLen - bufPos < 3)
{
DataStructureUtil.expandArray(ref buffer, 3);
bufLen = buffer.Length;
}
buffer[bufPos] = '%';
URIUtil.byteToHex((byte)ch, buffer.AsSpan(bufPos + 1));
bufPos += 3;
}
}
return(new string(buffer, 0, bufPos));
}
