public static int FindByPath(ItemTree tree, StringStore strings, string path, char delimiter = '\\')
{
String8 path8 = String8.Convert(path, new byte[String8.GetLength(path)]);
String8Set pathSplit8 = path8.Split(delimiter, new int[String8Set.GetLength(path8, delimiter)]);
return(tree.FindByPath(0, pathSplit8, strings));
}
public async Task WriteMessageCreatesQueueMessageFromStringTest()
{
var queueName = Guid.NewGuid().ToString("N");
var expected = Guid.NewGuid().ToString();
var target = new StringStore(Config.Storage.ConnectionString, queueName);
var storageAccount = CloudStorageAccount.Parse(Config.Storage.ConnectionString);
var client = storageAccount.CreateCloudQueueClient();
var queue = client.GetQueueReference(queueName);
try
{
await target.WriteMessage(expected, null, null, CancellationToken.None).ConfigureAwait(false);
var queueItem = await queue.GetMessageAsync().ConfigureAwait(false);
var actual = queueItem.AsString;
actual.Should().Be(expected);
}
finally
{
await queue.DeleteIfExistsAsync().ConfigureAwait(false);
}
}
public void UpdateIdentifiers(StringStore strings)
{
// Remap all words *and merge pages with only casing differences*
Dictionary <int, List <int> > remappedIndex = new Dictionary <int, List <int> >(_wordToItemsIndex.Count);
foreach (int wordIdentifier in _wordToItemsIndex.Keys)
{
int updatedIdentifier = strings.GetSerializationIdentifier(wordIdentifier);
Range wordMatches = strings.RangeForString(updatedIdentifier);
int firstCaseInsensitiveWordIdentifier = wordMatches.Start;
List <int> existingMatchesForWord;
if (!remappedIndex.TryGetValue(firstCaseInsensitiveWordIdentifier, out existingMatchesForWord))
{
// This is the first (or only) case-insensitive copy of the word - use the list we had
remappedIndex[firstCaseInsensitiveWordIdentifier] = _wordToItemsIndex[wordIdentifier];
}
else
{
// There are already values for another casing of this word.
// Merge them to the current list in sorted order (this preserves ranking, if indexing was done in ranked order)
existingMatchesForWord.AddRange(_wordToItemsIndex[wordIdentifier]);
existingMatchesForWord.Sort();
}
}
_wordToItemsIndex = remappedIndex;
}
public void init(string message)
{
label.text = message;
yesButton.setText(StringStore.retrieve("yes"));
noButton.setText(StringStore.retrieve("no"));
}
public bool TryFindByPath(int startIndex, String8Set path, StringStore strings, out int matchingIndex)
{
// If we find nothing we should return 0 (the root was the last matching thing we found)
matchingIndex = 0;
return(TryFindByPath(startIndex, 0, path, strings, ref matchingIndex));
}
public static List <CardData> retrieveCardDeck(string teamId)
{
string query = "SELECT id, teamId, player1Id, player2Id, value, inAction, outAction FROM cards WHERE teamId = '" + teamId + "'";
DataBaseHandler.open(Application.persistentDataPath + "/Data/PlayerData.db");
DataTable data = DataBaseHandler.executeQuery(query);
List <CardData> cardDataList = new List <CardData>();
for (int i = 0; i < data.Rows.Count; i++)
{
CardData cardData = new CardData();
cardData.id = data.Rows[i]["id"].ToString();
cardData.teamId = data.Rows[i]["teamId"].ToString();
cardData.title = StringStore.retrieve(cardData.id + "Title");
cardData.comment = StringStore.retrieve(cardData.id + "Comment");
cardData.action = StringStore.retrieve(cardData.id + "Action");
cardData.player1Id = data.Rows[i]["player1Id"].ToString();
cardData.player2Id = data.Rows[i]["player2Id"].ToString();
cardData.value = (int)data.Rows[i]["value"];
cardData.inAction = data.Rows[i]["inAction"].ToString();
cardData.outAction = data.Rows[i]["outAction"].ToString();
cardDataList.Add(cardData);
}
DataBaseHandler.close();
return(cardDataList);
}
public int FindByPath(int startIndex, String8Set path, StringStore strings)
{
int matchingIndex;
if (TryFindByPath(startIndex, path, strings, out matchingIndex))
{
return(matchingIndex);
}
StringBuilder message = new StringBuilder();
using (StringWriter writer = new StringWriter(message))
{
writer.Write("Could not find '");
path.Value.WriteTo(writer);
writer.WriteLine("' in tree.");
int partsFound = this.GetDepth(matchingIndex) - this.GetDepth(startIndex);
writer.Write("Could not find '");
path[partsFound].WriteTo(writer);
writer.Write("' under '");
this.GetPath(matchingIndex, strings, '|').WriteTo(writer);
writer.WriteLine("' with children:");
WriteChildrenOf(writer, strings, matchingIndex);
writer.WriteLine();
}
throw new TreeItemNotFoundException(message.ToString());
}
public void WriteBinary(BinaryWriter w)
{
// Don't write database if empty (BinarySerializable will detect and delete file)
if (IsEmpty)
{
return;
}
// Ensure the database has been converted to queryable/writable form
ConvertToImmutable();
w.Write(BinaryFileFormatVersion);
// Write strings
StringStore.WriteBinary(w);
// Write symbol tree
DeclaredMembers.WriteBinary(w);
// Write details
w.Write(DeclaredMemberDetails);
// Write symbol locations
w.Write(DeclaredMemberLocations);
// Write file tree
FileTree.WriteBinary(w);
// Write search index
Index.WriteBinary(w);
// Write identity details (last; likely to change)
// PackageIdentity must be last so DownloadCount can be seeked to
Identity.WriteBinary(w);
}
public async Task WriteWithNegativeVisibleInValueMakesDataImmediatelyAvailableTest()
{
var queueName = Guid.NewGuid().ToString("N");
var expected = Guid.NewGuid().ToString("N");
var target = new StringStore(Config.Storage.ConnectionString, queueName);
var storageAccount = CloudStorageAccount.Parse(Config.Storage.ConnectionString);
var client = storageAccount.CreateCloudQueueClient();
var queue = client.GetQueueReference(queueName);
try
{
await target.WriteMessage(expected, null, TimeSpan.FromMinutes(-1), CancellationToken.None)
.ConfigureAwait(false);
var queueItem = await queue.GetMessageAsync().ConfigureAwait(false);
var actual = queueItem.AsString;
actual.Should().Be(expected);
}
finally
{
await queue.DeleteIfExistsAsync().ConfigureAwait(false);
}
}
private bool MatchesDetailed(ItemTree declaredMembers, StringStore strings, IMemberDatabase db, int symbolIndex)
{
if (!Matches(declaredMembers, strings, symbolIndex))
{
return(false);
}
if (Type != SymbolType.Any && db.GetMemberType(symbolIndex) != Type)
{
return(false);
}
if (!Modifiers.Matches(db.GetMemberModifiers(symbolIndex)))
{
return(false);
}
// ISSUE: Need a way to specify you want the empty params overload of a method (other than full match)
// NOTE: Parameters8 was a copy gotten from StringStore to make this comparison fast (rather than a byte-by-byte comparison)
// NOTE: Case insensitive comparison because StringStore lookup was case-insensitive, so Parameters8 casing isn't specific
// NOTE: Need String8 rather than just checking Range.Contains because IMemberDatabase doesn't offer returning the identifier
if ((IsFullSuffix || !this.ParametersIdentifiers.IsEmpty()) && db.GetMemberParameters(symbolIndex).CompareTo(Parameters8, true) != 0)
{
return(false);
}
return(true);
}
private bool Matches(ItemTree declaredMembers, StringStore strings, int symbolIndex)
{
int candidateNameIdentifier = declaredMembers.GetNameIdentifier(symbolIndex);
if (!SymbolNameSuffixIdentifiers.Contains(candidateNameIdentifier))
{
return(false);
}
if (this.IgnoreCase == true)
{
return(true);
}
else
{
String8 candidateName8 = strings[candidateNameIdentifier];
if (this.IsFullSuffix)
{
return(this.SymbolNameSuffix.CompareTo(candidateName8, false) == 0);
}
else
{
return(this.SymbolNameSuffix.CompareAsPrefixTo(candidateName8, false) == 0);
}
}
}
public void UpdateIdentifiers(StringStore strings)
{
for (int i = 0; i < this.Count; ++i)
{
_nameIdentifier[i] = strings.GetSerializationIdentifier(_nameIdentifier[i]);
}
}
public void WriteTree(TextWriter writer, StringStore strings, int index = 0, int indent = -1, Action <int, TextWriter> writeAdditionalDetail = null)
{
// Write element (but only if indent is positive)
// Write everything under the sentinel root with WriteTree(w, s, 0, -1)
if (indent >= 0)
{
for (int i = 0; i < indent; ++i)
{
writer.Write('\t');
}
strings[this.GetNameIdentifier(index)].WriteTo(writer);
if (writeAdditionalDetail != null)
{
writeAdditionalDetail(index, writer);
}
writer.WriteLine();
}
int childIndex = this.GetFirstChild(index);
while (childIndex > 0)
{
WriteTree(writer, strings, childIndex, indent + 1, writeAdditionalDetail);
childIndex = this.GetNextSibling(childIndex);
}
}
internal bool ResolveStringsTo(StringStore store)
{
// If we've already resolved to this store, don't re-resolve
if (store == this.LastResolvedStore)
{
return(this.LastResolveResult);
}
// Record we last resolved against this store and failed
this.LastResolvedStore = store;
this.LastResolveResult = false;
// Look up symbol name *prefix* parts (all exact)
for (int i = 0; i < this.SplitSymbolName8.Count - 1; ++i)
{
if (!store.TryFindString(this.SplitSymbolName8[i], this.IgnoreCase, out this.SymbolNamePrefixIdentifiers[i]))
{
return(false);
}
}
// Look up symbol name suffix (exact only if IsFullSuffix)
if (this.IsFullSuffix)
{
if (!store.TryFindString(this.SymbolNameSuffix, this.IgnoreCase, out this.SymbolNameSuffixIdentifiers))
{
return(false);
}
}
else
{
if (this.SymbolNameSuffix.IsEmpty())
{
this.SymbolNameSuffixIdentifiers = Range.Max;
}
else
{
if (!store.TryGetRangeStartingWith(this.SymbolNameSuffix, out this.SymbolNameSuffixIdentifiers))
{
return(false);
}
// NOTE: Can't make a prefix Range case sensitive, so have to validate casing later
// Case-insensitive sort means you can have [..., array, Array, arrayList, ArrayList, ...], so no way to return case sensitive range starting with 'Array'
}
}
// Look up parameters [and get the copy from the StringStore for fast comparison on signature]
if (!store.TryFindString(this.Parameters8, this.IgnoreCase, out this.ParametersIdentifiers))
{
return(false);
}
this.Parameters8 = store[this.ParametersIdentifiers.Start];
// If we found everything, record we succeeded
this.LastResolveResult = true;
return(true);
}
internal Path8(StringStore strings, ItemTree tree, int index, byte delimiter, int includeDepth = -1)
{
_strings = strings;
_tree = tree;
_index = index;
_delimiter = (byte)delimiter;
_includeDepth = includeDepth;
}
public Path8(StringStore strings, ItemTree tree, int index, char delimiter, int includeDepth = -1)
: this(strings, tree, index, (byte)delimiter, includeDepth)
{
if ((ushort)delimiter >= 0x80)
{
throw new ArgumentException(String.Format(Resources.UnableToSupportMultibyteCharacter, delimiter));
}
}
public void Clear()
{
this.Strings = new StringStore();
this.NameIdentifiers = new PartialArray <int>();
this.TargetIdentifiers = new PartialArray <int>();
this.Types = new PartialArray <byte>();
this.EventTimes = new PartialArray <long>();
}
void Start()
{
SetPopupStartAni(true);
m_pStringStore_Src = GameObject.Find("JAImshiMng").transform.FindChild("JATextData").transform.FindChild("JATextXML").GetComponent <StringStore>();
m_pTitleLabel.text = m_pStringStore_Src.strings[0];
m_pMainLabel.text = m_pStringStore_Src.strings[JAManager.I.m_nSelectPopTextIndex];
}
private void userTurnEnded()
{
match.currentTeam.endTurn();
match.currentTeam = match.currentTeam.opponentTeam;
TurnOverlay turnOverlay = GUICreator.instantiateTurnOverlay();
turnOverlay.init(StringStore.retrieve("Turn") + " " + match.currentTeam.teamData.name, onTurnOverlayEnded);
}
public void String8Column_Basic()
{
StringStore store = new StringStore();
String8Block block = new String8Block();
String8[] samples = new String8[] { String8.Empty, block.GetCopy("One"), block.GetCopy("two"), block.GetCopy("three") };
String8Column column = new String8Column(store);
Assert.AreEqual(0, column.Count);
Verify.Exception <ArgumentOutOfRangeException>(() => { String8 value = column[0]; });
// Set values and verify they are read back consistently (all UTC)
for (int i = 0; i < samples.Length; ++i)
{
column.Add();
column[i] = samples[i];
Assert.AreEqual(samples[i], column[i]);
}
Assert.AreEqual(samples.Length, column.Count);
// Round-Trip the column
column.ConvertToImmutable();
StringStore readStore = new StringStore();
Verify.RoundTrip(store, readStore);
String8Column readColumn = new String8Column(readStore);
Verify.RoundTrip <String8Column>(column, readColumn);
Assert.AreEqual(column.Count, readColumn.Count);
for (int i = 0; i < column.Count; ++i)
{
Assert.AreEqual(column[i], readColumn[i]);
}
// Verify asking for raw identifiers works
int firstStringIdentifier = column.IdentifierFor(1);
Assert.AreEqual(store[firstStringIdentifier], column[1]);
// Verify clear works
column.Clear();
Assert.AreEqual(0, column.Count);
Verify.Exception <ArgumentOutOfRangeException>(() => { String8 value = column[0]; });
// Verify SetCount works
column.SetCount(2);
Assert.AreEqual(2, column.Count);
Assert.AreEqual(String8.Empty, column[1]);
}
private string MatchesForPrefixToString(MemberIndex index, StringStore strings, String8 prefix)
{
Range matches;
if (!strings.TryGetRangeStartingWith(prefix, out matches))
{
return(String.Empty);
}
return(MatchesToString(index, matches));
}
private string MatchesForWordToString(MemberIndex index, StringStore strings, String8 word)
{
Range matches;
if (!strings.TryFindString(word, out matches))
{
return(String.Empty);
}
return(MatchesToString(index, matches));
}
public void WriteMessageThrowsExceptionWhenValueIsNullTest()
{
var queueName = Guid.NewGuid().ToString("N");
var target = new StringStore(Config.Storage.ConnectionString, queueName);
Func <Task> action = async() =>
await target.WriteMessage(null, null, null, CancellationToken.None).ConfigureAwait(false);
action.Should().Throw <ArgumentNullException>();
}
public void AlphanumericSplitter_EndToEndPerformance()
{
String8 code = AllCodeText.AllCode8;
String8Set set = default(String8Set);
PartialArray <int> matchContainer = new PartialArray <int>(2048);
HashSet <String8> uniqueWords = new HashSet <String8>();
StringStore strings = new StringStore();
MemberIndex index = new MemberIndex();
int iterations = 10;
int totalWordsSplit = 0;
// Split, Add, Index Goal: 30k per millisecond [30 MB/sec]
Verify.PerformanceByBytes(30 * LongExtensions.Megabyte, () =>
{
for (int iteration = 0; iteration < iterations; ++iteration)
{
String8Set codeByLine = code.Split(UTF8.Newline, new PartialArray <int>());
for (int lineIndex = 0; lineIndex < codeByLine.Count; ++lineIndex)
{
// Convert and Split the line
String8 line = codeByLine[lineIndex];
set = AlphanumericSplitter.Split(line, ref matchContainer);
totalWordsSplit += set.Count;
if (set.Count > 0)
{
int matchIndex = AlphanumericSplitter.IsAlphaNumeric(set[0][0]) ? 0 : 1;
for (; matchIndex < set.Count; matchIndex += 2)
{
// If the word is long enough...
String8 word = set[matchIndex];
if (word.Length > 2)
{
if (!uniqueWords.Contains(word))
{
int wordIdentifier = strings.FindOrAddString(word);
uniqueWords.Add(strings[wordIdentifier]);
index.AddItem(wordIdentifier, lineIndex);
}
}
}
}
}
}
return(iterations * code.Length);
});
}
public MergedMembersDatabase(StringStore sharedStore = null)
{
this.StringStore = sharedStore;
if (this.StringStore == null)
{
this.StringStore = new StringStore();
}
this.MergedMembers = new ItemTree();
this.MergedMemberSourcePackageIdentifier = new PartialArray <int>();
this.MergedMemberSourcePackageIdentifier.Add(0);
this.MergedMemberDuplicateCount = new PartialArray <int>();
this.MergedMemberDuplicateCount.Add(0);
}
public void MemberIndex_Basic()
{
StringStore strings = new StringStore();
MemberIndex index = new MemberIndex();
// Add six sample strings to StringStore
string[] testValues = new string[] { "Zero", "One", "Two", "Three", "Four", "Five" };
int[] testValueIDs = new int[testValues.Length];
for (int i = 0; i < testValues.Length; ++i)
{
testValueIDs[i] = strings.FindOrAddString(testValues[i]);
}
// Add 100 items to index - each item has the values it is evenly divisible by (10 has "Five" and "Two")
for (int indexId = 1; indexId < 20; ++indexId)
{
for (int wordIndex = 1; wordIndex < testValueIDs.Length; ++wordIndex)
{
if (indexId % wordIndex == 0)
{
index.AddItem(testValueIDs[wordIndex], indexId);
}
}
}
// Convert for search
strings.ConvertToImmutable();
index.ConvertToImmutable(strings);
// Verify matches for three are correct
Assert.AreEqual("3, 6, 9, 12, 15, 18", MatchesForWordToString(index, strings, strings[testValueIDs[3]]));
Assert.AreEqual("3, 6, 9, 12, 15, 18", MatchesForPrefixToString(index, strings, String8.Convert("Three", new byte[String8.GetLength("Three")])));
// Verify matches for five are correct
Assert.AreEqual("5, 10, 15", MatchesForWordToString(index, strings, strings[testValueIDs[5]]));
Assert.AreEqual("5, 10, 15", MatchesForPrefixToString(index, strings, String8.Convert("Five", new byte[String8.GetLength("Five")])));
// Verify no matches for zero
Assert.AreEqual("", MatchesForWordToString(index, strings, strings[testValueIDs[0]]));
Assert.AreEqual("", MatchesForPrefixToString(index, strings, String8.Convert("Zero", new byte[String8.GetLength("Zero")])));
// Verify "Four" and "Five" matches for "F"
Assert.AreEqual("5, 10, 15, 4, 8, 12, 16", MatchesForPrefixToString(index, strings, String8.Convert("F", new byte[String8.GetLength("F")])));
}
public void ReadBinary(BinaryReader r)
{
int formatVersion = r.ReadInt32();
if (formatVersion != BinaryFileFormatVersion)
{
throw new IOException(String.Format(Resources.DatabaseFormatVersionWrong, BinaryFileFormatVersion, formatVersion));
}
StringStore.ReadBinary(r);
DeclaredMembers.ReadBinary(r);
DeclaredMemberDetails = r.ReadList <SymbolDetails>();
DeclaredMemberLocations = r.ReadList <SymbolLocation>();
FileTree.ReadBinary(r);
Index.ReadBinary(r);
// PackageIdentity must be last so DownloadCount can be seeked to
Identity.ReadBinary(r);
}
public int AddPath(int rootIndex, String8Set path, StringStore strings)
{
int currentIndex = rootIndex;
for (int i = 0; i < path.Count; ++i)
{
String8 part = path[i];
int partNameIdentifier = strings.FindOrAddString(part);
int foundNode;
if (!TryFindChildByName(currentIndex, partNameIdentifier, out foundNode))
{
foundNode = Add(currentIndex, partNameIdentifier);
}
currentIndex = foundNode;
}
return(currentIndex);
}
public void WriteChildrenOf(TextWriter writer, StringStore strings, int parentIndex)
{
// Consider -1 (not found) to be the same as the sentinel root
if (parentIndex == -1)
{
parentIndex = 0;
}
int childIndex = this.GetFirstChild(parentIndex);
while (childIndex > 0)
{
strings[this.GetNameIdentifier(childIndex)].WriteTo(writer);
childIndex = this.GetNextSibling(childIndex);
if (childIndex > 0)
{
writer.Write(", ");
}
}
}
private static void CountNonAsciiStrings(string databasePath)
{
int nonAsciiPackageDownloadCount = 0;
int packageCount = 0;
int stringCount = 0;
int packagesWithNonAscii = 0;
int stringsWithNonAscii = 0;
using (new TraceWatch("Counting Non-Ascii in '{0}'...", databasePath))
{
// Load individual package databases
foreach (PackageDatabase db in BinarySerializableExtensions.LoadEach <PackageDatabase>(Directory.GetFiles(databasePath), true))
{
bool isPackageAllAscii = true;
StringStore strings = ((IMemberDatabase)db).StringStore;
for (int i = 0; i < strings.Count; ++i)
{
if (strings[i].IsAscii() == false)
{
stringsWithNonAscii++;
isPackageAllAscii = false;
}
}
stringCount += strings.Count;
packageCount++;
if (!isPackageAllAscii)
{
packagesWithNonAscii++;
nonAsciiPackageDownloadCount += db.Identity.DownloadCount;
Trace.WriteLine(String.Format("Non-ASCII: {0} [{1} downloads]", db.Identity.PackageName, db.Identity.DownloadCount));
}
}
}
Console.WriteLine("{0:n0} / {1:n0} packages contain non-Ascii; {2:n0} / {3:n0} strings.", packagesWithNonAscii, packageCount, stringsWithNonAscii, stringCount);
Console.WriteLine("Total Non-Ascii Package Downloads: {0:n0}", nonAsciiPackageDownloadCount);
}