private HashSet <string> GetMatchingCharacterIds(string textToFind) { HashSet <string> matchingCharacterIds; if (!m_findTextToMatchingCharacterIds.TryGetValue(textToFind, out matchingCharacterIds)) { if (CharacterDetailData.Singleton.GetAll().Count() != CharacterVerseData.SingletonLocalizedCharacterIdToCharacterIdDictionary.Count) { // First time getting UI versions of character IDs (typically when running tests), so we need to force // population of CharacterVerseData.SingletonLocalizedCharacterIdToCharacterIdDictionary. foreach (var characterId in CharacterGroups.SelectMany(characterGroup => characterGroup.CharacterIds)) { CharacterVerseData.GetCharacterNameForUi(characterId); } } matchingCharacterIds = new HashSet <string>(); m_findTextToMatchingCharacterIds.Add(textToFind, matchingCharacterIds); foreach (var kvp in CharacterVerseData.SingletonLocalizedCharacterIdToCharacterIdDictionary) { if (kvp.Value.IndexOf(textToFind, StringComparison.OrdinalIgnoreCase) >= 0) { matchingCharacterIds.Add(kvp.Key); } } } return(matchingCharacterIds); }
/// <summary> /// Generates a password with the given length. /// </summary> /// <param name="length">The length of the password to be generated.</param> /// <returns>A randomly generated password.</returns> public string GeneratePassword(int length) { if (length < MinLength) { throw new ArgumentOutOfRangeException(nameof(length), $"The length of the generated password must be at least {MinLength} characters."); } // Create a collection of character groups the size of the password to be generated. // The number of times a character group appears in this collection is equal to the // minimum number of occurrences of that character group. An AllCharacters group is // created to fill in the characters not accounted for by the other character groups. List <CharacterGroup> characterGroups = CharacterGroups .SelectMany(characterGroup => Enumerable.Repeat(characterGroup, characterGroup.MinOccurrence)) .Concat(Enumerable.Repeat(new CharacterGroup(AllCharacters), length - MinLength)) .ToList(); char[] passwordChars = new char[length]; for (int i = 0; i < length; i++) { // Pull a random character from the character group into the password CharacterGroup characterGroup = characterGroups[i]; int index = Random.Int32Between(0, characterGroup.Characters.Length); passwordChars[i] = characterGroup.Characters[index]; } // Scramble the generated set of characters passwordChars.Scramble(); return(new string(passwordChars)); }
public void Sort(SortedBy by, bool sortAscending) { Comparison <CharacterGroup> how; int direction = sortAscending ? kAscending : kDescending; switch (by) { case SortedBy.Name: how = (a, b) => String.Compare(a.Name, b.Name, StringComparison.CurrentCulture) * direction; break; case SortedBy.Attributes: how = (a, b) => String.Compare(a.AttributesDisplay, b.AttributesDisplay, StringComparison.CurrentCulture) * direction; break; case SortedBy.Actor: how = (a, b) => { var actorA = m_project.VoiceActorList.GetVoiceActorById(a.VoiceActorId); var nameA = actorA == null ? String.Empty : actorA.Name; var actorB = m_project.VoiceActorList.GetVoiceActorById(b.VoiceActorId); var nameB = actorB == null ? String.Empty : actorB.Name; return(String.Compare(nameA, nameB, StringComparison.CurrentCulture) * direction); }; break; case SortedBy.EstimatedTime: how = (a, b) => a.EstimatedHours.CompareTo(b.EstimatedHours) * direction; break; default: throw new ArgumentException("Unexpected sorting method", "by"); } CharacterGroups.Sort(how); }
void Start() { if (main == null) main = this; else if (main == this) Destroy(gameObject); }
/// <summary> /// Note: There should only ever be one such group, but early on, Glyssen would allow the same /// actor to be assigned to multiple groups, so for compatibility reasons, we allow for this. /// </summary> public IEnumerable <CharacterGroup> GetGroupsAssignedToActor(int actorId) { if (actorId <= CharacterGroup.kNoActorAssigned) { throw new ArgumentException("GetGroupsAssignedToActor should not be used to get groups assigned to no actor (no good reason; it just shouldn't)."); } return(CharacterGroups.Where(g => g.VoiceActorId == actorId)); }
public IRandomStringGenerationBuilder AndAllowCharacters(CharacterGroups characters) { foreach (var c in CharacterGroup.Get(characters)) { this.allowedCharacters.Add(c); } return(this); }
public VoiceActorAssignmentViewModel(Project project) { m_project = project; CharacterGroupAttribute <CharacterGender> .GetUiStringForValue = GetUiStringForCharacterGender; CharacterGroupAttribute <CharacterAge> .GetUiStringForValue = GetUiStringForCharacterAge; #if DEBUG var p = new Proximity(m_project.IncludedBooks, m_project.DramatizationPreferences); foreach (var group in CharacterGroups.OrderBy(g => g.GroupIdForUiDisplay)) { Debug.WriteLine(group.GroupIdForUiDisplay + ": " + p.CalculateMinimumProximity(group.CharacterIds)); } #endif }
public VoiceActorAssignmentViewModel(Project project) { m_project = project; ProjectProximity = new Proximity(m_project, false); CharacterGroupAttribute <CharacterGender> .GetUiStringForValue = GetUiStringForCharacterGender; CharacterGroupAttribute <CharacterAge> .GetUiStringForValue = GetUiStringForCharacterAge; LogAndOutputToDebugConsole("Group".PadRight(7) + ": " + MinimumProximity.ReportHeader + Environment.NewLine + "-".PadRight(100, '-')); foreach (var group in CharacterGroups.OrderBy(g => g.GroupIdForUiDisplay)) { LogAndOutputToDebugConsole(group.GroupIdForUiDisplay.PadRight(7) + ": " + ProjectProximity.CalculateMinimumProximity(group.CharacterIds)); } }
// Keep this method around for now in case we decide to support templates in some scenarios // ReSharper disable once UnusedMember.Local private void CreateInitialGroupsFromTemplate() { CharacterGroupTemplate charGroupTemplate; using (var tempFile = new TempFile()) { File.WriteAllBytes(tempFile.Path, Resources.CharacterGroups); ICharacterGroupSource charGroupSource = new CharacterGroupTemplateExcelFile(m_project, tempFile.Path); charGroupTemplate = charGroupSource.GetTemplate(m_project.VoiceActorList.Actors.Count); } HashSet <string> includedCharacterIds = new HashSet <string>(); foreach (var book in m_project.IncludedBooks) { foreach (var block in book.GetScriptBlocks(true)) { if (!block.CharacterIsUnclear()) { includedCharacterIds.Add(block.CharacterId); } } } ISet <string> matchedCharacterIds = new HashSet <string>(); foreach (var group in charGroupTemplate.CharacterGroups.Values) { group.CharacterIds.IntersectWith(includedCharacterIds); if (!group.CharacterIds.Any()) { continue; } CharacterGroups.Add(group); matchedCharacterIds.AddRange(group.CharacterIds); } // Add an extra group for any characters which weren't in the template var unmatchedCharacters = includedCharacterIds.Except(matchedCharacterIds); var unmatchedCharacterGroup = new CharacterGroup(m_project, ByKeyStrokeComparer); unmatchedCharacterGroup.GroupNumber = 999; unmatchedCharacterGroup.CharacterIds.AddRange(unmatchedCharacters); CharacterGroups.Add(unmatchedCharacterGroup); }
public VoiceActorAssignmentViewModel(Project project, Dictionary <string, int> keyStrokesByCharacterId = null) { m_project = project; m_keyStrokesByCharacterId = keyStrokesByCharacterId ?? m_project.GetKeyStrokesByCharacterId(); CharacterGroupAttribute <CharacterGender> .GetUiStringForValue = GetUiStringForCharacterGender; CharacterGroupAttribute <CharacterAge> .GetUiStringForValue = GetUiStringForCharacterAge; m_project.CharacterGroupList.PopulateEstimatedHours(m_keyStrokesByCharacterId); #if DEBUG var p = new Proximity(m_project); foreach (var group in CharacterGroups.OrderBy(g => g.GroupNumber)) { Debug.WriteLine(group.GroupNumber + ": " + p.CalculateMinimumProximity(group.CharacterIds)); } #endif }
private CharacterGroup GetSourceGroupForMove(IList <string> characterIds, CharacterGroup destGroup) { if (characterIds.Count == 0) { throw new ArgumentException("At least one characterId must be provided", "characterIds"); } // Currently, we assume all characterIds are coming from the same source group CharacterGroup sourceGroup = CharacterGroups.FirstOrDefault(t => t.CharacterIds.Contains(characterIds[0])); // REVIEW: The second part of this condition used to be done in the following "if" statement, but I can't // think of any reason why moving a character to the group it's already in should result in any unused groups. if (sourceGroup == null || sourceGroup == destGroup) { return(null); } if (destGroup == null && !sourceGroup.IsVoiceActorAssigned && sourceGroup.CharacterIds.SetEquals(characterIds)) { return(null); // Moving all characetrs from an unassigned group to a new group would accomplish nothing. } return(sourceGroup); }
public static char[] Get(CharacterGroups allowedCharacters) { if (allowedCharacters == CharacterGroups.None) { throw new ArgumentOutOfRangeException(nameof(allowedCharacters), "At least one character group is needed to generate a random string."); } var allowedCharactersArrayLength = 0; if (allowedCharacters.HasFlag(CharacterGroups.UpperCaseLetters)) { allowedCharactersArrayLength += CharacterGroup.UpperCaseLetters.Length; } if (allowedCharacters.HasFlag(CharacterGroups.LowerCaseLetters)) { allowedCharactersArrayLength += CharacterGroup.LowerCaseLetters.Length; } if (allowedCharacters.HasFlag(CharacterGroups.Digits)) { allowedCharactersArrayLength += CharacterGroup.Digits.Length; } if (allowedCharacters.HasFlag(CharacterGroups.Minus)) { allowedCharactersArrayLength += CharacterGroup.Minus.Length; } if (allowedCharacters.HasFlag(CharacterGroups.Underscore)) { allowedCharactersArrayLength += CharacterGroup.Underscore.Length; } if (allowedCharacters.HasFlag(CharacterGroups.Space)) { allowedCharactersArrayLength += CharacterGroup.Space.Length; } if (allowedCharacters.HasFlag(CharacterGroups.Brackets)) { allowedCharactersArrayLength += CharacterGroup.Bracket.Length; } if (allowedCharacters.HasFlag(CharacterGroups.SpecialReadableAsciiLetters)) { allowedCharactersArrayLength += CharacterGroup.SpecialReadableAscriiLetters.Length; } var finalArray = new char[allowedCharactersArrayLength]; var offset = 0; const int itemSize = sizeof(char); if (allowedCharacters.HasFlag(CharacterGroups.UpperCaseLetters)) { Buffer.BlockCopy(CharacterGroup.UpperCaseLetters, 0, finalArray, offset, CharacterGroup.UpperCaseLetters.Length * itemSize); offset += (CharacterGroup.UpperCaseLetters.Length * sizeof(char)); } if (allowedCharacters.HasFlag(CharacterGroups.LowerCaseLetters)) { Buffer.BlockCopy(CharacterGroup.LowerCaseLetters, 0, finalArray, offset, CharacterGroup.LowerCaseLetters.Length * itemSize); offset += (CharacterGroup.LowerCaseLetters.Length * sizeof(char)); } if (allowedCharacters.HasFlag(CharacterGroups.Digits)) { Buffer.BlockCopy(CharacterGroup.Digits, 0, finalArray, offset, CharacterGroup.Digits.Length * itemSize); offset += (CharacterGroup.Digits.Length * sizeof(char)); } if (allowedCharacters.HasFlag(CharacterGroups.Minus)) { Buffer.BlockCopy(CharacterGroup.Minus, 0, finalArray, offset, CharacterGroup.Minus.Length * itemSize); offset += (CharacterGroup.Minus.Length * sizeof(char)); } if (allowedCharacters.HasFlag(CharacterGroups.Underscore)) { Buffer.BlockCopy(CharacterGroup.Underscore, 0, finalArray, offset, CharacterGroup.Underscore.Length * itemSize); offset += (CharacterGroup.Underscore.Length * sizeof(char)); } if (allowedCharacters.HasFlag(CharacterGroups.Space)) { Buffer.BlockCopy(CharacterGroup.Space, 0, finalArray, offset, CharacterGroup.Space.Length * itemSize); offset += (CharacterGroup.Space.Length * sizeof(char)); } if (allowedCharacters.HasFlag(CharacterGroups.Brackets)) { Buffer.BlockCopy(CharacterGroup.Bracket, 0, finalArray, offset, CharacterGroup.Bracket.Length * itemSize); offset += (CharacterGroup.Bracket.Length * sizeof(char)); } if (allowedCharacters.HasFlag(CharacterGroups.SpecialReadableAsciiLetters)) { Buffer.BlockCopy(CharacterGroup.SpecialReadableAscriiLetters, 0, finalArray, offset, CharacterGroup.SpecialReadableAscriiLetters.Length * itemSize); // do not forget offset increment when adding new character groups after this! } return(finalArray); }
/// <summary> /// Generates a random string based on specified options. /// </summary> /// <param name="length">The desired length of the generated string.</param> /// <param name="allowedCharacters">The set of allowed characters used for string generation.</param> /// <param name="eachCharacterMustOccurAtLeastOnce">Specifies whether each character in the <paramref name="allowedCharacters"/> /// array must occur at least once in the generated random string.</param> /// <returns>The generated string.</returns> protected virtual string CoreCreate(int length, CharacterGroups allowedCharacters, bool eachCharacterMustOccurAtLeastOnce) => this.CoreCreate(length, CharacterGroup.Get(allowedCharacters), eachCharacterMustOccurAtLeastOnce);
/// <summary> /// Generates a random string based on specified options. /// </summary> /// <param name="length">The desired length of the generated string.</param> /// <param name="allowedCharacters">The set of allowed characters used for string generation.</param> /// <param name="eachCharacterMustOccurAtLeastOnce">Specifies whether each character in the <paramref name="allowedCharacters"/> /// array must occur at least once in the generated random string.</param> /// <returns>The generated string.</returns> public virtual string Generate(int length, CharacterGroups allowedCharacters, bool eachCharacterMustOccurAtLeastOnce = false) => this.CoreCreate(length, allowedCharacters, eachCharacterMustOccurAtLeastOnce);
/// <summary> /// Converts the selected <see cref="CharacterGroups"/> to a char array. /// </summary> /// <param name="groups">The selected character groups.</param> /// <returns>A char array representing the selected character groups.</returns> public static char[] ToCharArray(this CharacterGroups groups) { // we use an extension method so that we do not have to make the whole class public. return(CharacterGroup.Get(groups)); }
public IRandomStringGenerationBuilder AllowCharacters(CharacterGroups characters) { this.allowedCharacters = new List <char>(CharacterGroup.Get(characters)); return(this); }