public static async Task <List <string> > GetAllLanguageCodes(
this IQueryable <LanguageCode> languageCodes,
string mediaCode)
{
if (string.IsNullOrWhiteSpace(mediaCode))
{
return(new List <string>());
}
string code = mediaCode.ToLowerInvariant();
List <LanguageCode> maybeLanguages = await languageCodes
.Filter(lc => lc.ThreeCode1 == code || lc.ThreeCode2 == code)
.ToListAsync();
var result = new System.Collections.Generic.HashSet <string>();
foreach (LanguageCode language in maybeLanguages)
{
if (!string.IsNullOrWhiteSpace(language.ThreeCode1))
{
result.Add(language.ThreeCode1);
}
if (!string.IsNullOrWhiteSpace(language.ThreeCode2))
{
result.Add(language.ThreeCode2);
}
}
return(result.ToList());
}
protected bool ThisHasBeenDuplicated(UniqueItemDuplicated check)
{
if (staticInit == false || instances == null)
{
FindAllInstances();
}
// If it hasn't been awoken then it must be unique
if (awoken == false)
{
awoken = true;
return(false);
}
// It may be a clone
else
{
foreach (var instance in instances)
{
if (instance != null && instance != this)
{
if (check(instance) == true)
{
instances.Add((T)this);
return(true);
}
}
}
}
instances.Add((T)this);
return(false);
}
public static async Task <List <string> > GetAllLanguageCodes(
this IQueryable <LanguageCode> languageCodes,
List <string> mediaCodes)
{
var validCodes = mediaCodes
.Filter(c => !string.IsNullOrWhiteSpace(c))
.Map(c => c.ToLowerInvariant())
.ToList();
if (validCodes.Count == 0)
{
return(new List <string>());
}
List <LanguageCode> maybeLanguages = await languageCodes
.Filter(lc => validCodes.Contains(lc.ThreeCode1) || validCodes.Contains(lc.ThreeCode2))
.ToListAsync();
var result = new System.Collections.Generic.HashSet <string>();
foreach (LanguageCode language in maybeLanguages)
{
if (!string.IsNullOrWhiteSpace(language.ThreeCode1))
{
result.Add(language.ThreeCode1);
}
if (!string.IsNullOrWhiteSpace(language.ThreeCode2))
{
result.Add(language.ThreeCode2);
}
}
return(result.ToList());
}
static partial void PostRegisterGameObjUserHook(AKRESULT result, UnityEngine.GameObject gameObject, ulong id)
{
#if UNITY_EDITOR
if (Application.isPlaying)
#endif
{
if (result == AKRESULT.AK_Success)
{
RegisteredGameObjects.Add(id);
}
}
}
private static async Task <List <HardwareAccelerationKind> > GetSupportedAccelerationKinds(
string ffmpegPath,
CancellationToken cancellationToken)
{
var result = new System.Collections.Generic.HashSet <HardwareAccelerationKind>();
string output = await GetProcessOutput(ffmpegPath, new[] { "-v", "quiet", "-hwaccels" }, cancellationToken);
foreach (string method in output.Split("\n").Map(s => s.Trim()).Skip(1))
{
switch (method)
{
case "vaapi":
result.Add(HardwareAccelerationKind.Vaapi);
break;
case "nvenc":
result.Add(HardwareAccelerationKind.Nvenc);
break;
case "cuda":
result.Add(HardwareAccelerationKind.Nvenc);
break;
case "qsv":
result.Add(HardwareAccelerationKind.Qsv);
break;
case "videotoolbox":
result.Add(HardwareAccelerationKind.VideoToolbox);
break;
}
}
return(result.ToList());
}
static void Main()
{
var n = long.Parse(Console.ReadLine());
var s = new System.Collections.Generic.HashSet <long>();
for (var i = 2L; i *i <= n; i++)
{
var x = 1L * i * i;
for (; x <= n; x *= i)
{
s.Add(x);
}
}
Console.WriteLine(n - s.Count);
}
public void ValidateShaderResources(ShaderPathID shaderPathID)
{
string path = AssetDatabase.GUIDToAssetPath(ShaderUtils.GetShaderGUID(shaderPathID));
Assert.IsFalse(string.IsNullOrEmpty(path));
var shader = AssetDatabase.LoadAssetAtPath <Shader>(path);
Assert.AreEqual(shader.name, ShaderUtils.GetShaderPath(shaderPathID));
var propertyNames = new System.Collections.Generic.HashSet <string>();
for (int j = 0; j < shader.GetPropertyCount(); ++j)
{
string propertyName = shader.GetPropertyName(j);
Assert.IsFalse(propertyNames.Contains(propertyName), $"{shader.name} has duplicated property {propertyName}!");
propertyNames.Add(propertyName);
}
}
private async Task AddLanguages(ISearchRepository searchRepository, Document doc, List <string> mediaCodes)
{
var englishNames = new System.Collections.Generic.HashSet <string>();
foreach (string code in await searchRepository.GetAllLanguageCodes(mediaCodes))
{
Option <CultureInfo> maybeCultureInfo = _cultureInfos.Find(
ci => string.Equals(ci.ThreeLetterISOLanguageName, code, StringComparison.OrdinalIgnoreCase));
foreach (CultureInfo cultureInfo in maybeCultureInfo)
{
englishNames.Add(cultureInfo.EnglishName);
}
}
foreach (string englishName in englishNames)
{
doc.Add(new TextField(LanguageField, englishName, Field.Store.NO));
}
}
protected void OnKeyPressEvent(object sender, KeyPressEventArgs a)
{
if (selectedControls == null)
{
return;
}
var key = a.Event.Key;
if (pressed.Contains(key))
{
return;
}
if (key == Gdk.Key.Shift_L)
{
selectedControls = shiftedControls;
foreach (var ctrl in shiftlessControls)
{
if (pressed.Contains(ctrl.Key))
{
ctrl.Value.Stop();
if (shiftedControls.ContainsKey(ctrl.Key))
{
shiftedControls[ctrl.Key].Start();
}
}
}
}
else
{
if (!selectedControls.ContainsKey(key))
{
return;
}
pressed.Add(key);
selectedControls[key].Start();
}
}
public void Create()
{
int random_level_width, maps_to_create = number_of_maps.text == "" ? 20 : int.Parse(number_of_maps.text);
int level_width = int.Parse(width.text);
int level_height = int.Parse(height.text);
while (maps_to_create > 0)
{
random_level_width = UnityEngine.Random.Range(2, 4);
LevelMap m =
LevelMap.GetRandomMap(level_width, level_height);
if (!current_maps_hash.Contains(m.map_id))
{
m.Save("map_" + (current_maps_hash.Count + 1) + ".map");
print("MAP CREATED: " + m.map_id);
current_maps_hash.Add(m.map_id);
maps_to_create--;
}
}
SetupCanvasController.CreateMapSet();
}
private static void CheckTypeCompatibility(Type t, System.Collections.Generic.HashSet <Type> checkedItems = null)
{
if (checkedItems == null)
{
checkedItems = new System.Collections.Generic.HashSet <Type>();
checkedItems.Add(typeof(char));
checkedItems.Add(typeof(byte));
checkedItems.Add(typeof(sbyte));
checkedItems.Add(typeof(bool));
checkedItems.Add(typeof(double));
checkedItems.Add(typeof(float));
checkedItems.Add(typeof(decimal));
checkedItems.Add(typeof(int));
checkedItems.Add(typeof(short));
checkedItems.Add(typeof(long));
checkedItems.Add(typeof(uint));
checkedItems.Add(typeof(ushort));
checkedItems.Add(typeof(ulong));
checkedItems.Add(typeof(IntPtr));
checkedItems.Add(typeof(void *));
}
if (checkedItems.Contains(t))
return; }
public void found(Interaction interaction)
{
foundInteractions.Add(interaction);
updateObjective();
}
public static IList <string> GenerateArguments(
Option <VideoInputFile> maybeVideoInputFile,
Option <AudioInputFile> maybeAudioInputFile,
Option <WatermarkInputFile> maybeWatermarkInputFile,
Option <ConcatInputFile> maybeConcatInputFile,
IList <IPipelineStep> pipelineSteps)
{
var arguments = new List <string>();
foreach (IPipelineStep step in pipelineSteps)
{
arguments.AddRange(step.GlobalOptions);
}
var includedPaths = new System.Collections.Generic.HashSet <string>();
foreach (VideoInputFile videoInputFile in maybeVideoInputFile)
{
includedPaths.Add(videoInputFile.Path);
foreach (IInputOption step in videoInputFile.InputOptions)
{
arguments.AddRange(step.InputOptions(videoInputFile));
}
arguments.AddRange(new[] { "-i", videoInputFile.Path });
}
foreach (AudioInputFile audioInputFile in maybeAudioInputFile)
{
if (!includedPaths.Contains(audioInputFile.Path))
{
includedPaths.Add(audioInputFile.Path);
foreach (IInputOption step in audioInputFile.InputOptions)
{
arguments.AddRange(step.InputOptions(audioInputFile));
}
arguments.AddRange(new[] { "-i", audioInputFile.Path });
}
}
foreach (WatermarkInputFile watermarkInputFile in maybeWatermarkInputFile)
{
if (!includedPaths.Contains(watermarkInputFile.Path))
{
includedPaths.Add(watermarkInputFile.Path);
foreach (IInputOption step in watermarkInputFile.InputOptions)
{
arguments.AddRange(step.InputOptions(watermarkInputFile));
}
arguments.AddRange(new[] { "-i", watermarkInputFile.Path });
}
}
foreach (ConcatInputFile concatInputFile in maybeConcatInputFile)
{
foreach (IInputOption step in concatInputFile.InputOptions)
{
arguments.AddRange(step.InputOptions(concatInputFile));
}
arguments.AddRange(new[] { "-i", concatInputFile.Path });
}
foreach (IPipelineStep step in pipelineSteps)
{
arguments.AddRange(step.FilterOptions);
}
foreach (IPipelineStep step in pipelineSteps.Filter(s => s is not StreamSeekFilterOption))
{
arguments.AddRange(step.OutputOptions);
}
return(arguments);
}
protected async Task <Either <BaseError, TraktList> > MatchListItems(TvContext dbContext, TraktList list)
{
try
{
var ids = new System.Collections.Generic.HashSet <int>();
foreach (TraktListItem item in list.Items
.OrderBy(i => i.Title).ThenBy(i => i.Year).ThenBy(i => i.Season).ThenBy(i => i.Episode))
{
switch (item.Kind)
{
case TraktListItemKind.Movie:
Option <int> maybeMovieId = await IdentifyMovie(dbContext, item);
foreach (int movieId in maybeMovieId)
{
ids.Add(movieId);
item.MediaItemId = movieId;
}
break;
case TraktListItemKind.Show:
Option <int> maybeShowId = await IdentifyShow(dbContext, item);
foreach (int showId in maybeShowId)
{
ids.Add(showId);
item.MediaItemId = showId;
}
break;
case TraktListItemKind.Season:
Option <int> maybeSeasonId = await IdentifySeason(dbContext, item);
foreach (int seasonId in maybeSeasonId)
{
ids.Add(seasonId);
item.MediaItemId = seasonId;
}
break;
default:
Option <int> maybeEpisodeId = await IdentifyEpisode(dbContext, item);
foreach (int episodeId in maybeEpisodeId)
{
ids.Add(episodeId);
item.MediaItemId = episodeId;
}
break;
}
}
await dbContext.SaveChangesAsync();
foreach (int mediaItemId in ids)
{
Option <MediaItem> maybeItem = await _searchRepository.GetItemToIndex(mediaItemId);
foreach (MediaItem item in maybeItem)
{
await _searchIndex.UpdateItems(_searchRepository, new[] { item }.ToList());
}
}
_searchIndex.Commit();
return(list);
}
catch (Exception ex)
{
_logger.LogError(ex, "Error matching trakt list items");
return(BaseError.New(ex.Message));
}
}
/// <summary>
/// Asset Bundle-like export, except using DataNode's deep serialization.
/// </summary>
static public void ExportAssets(DataNode.SaveType type, string path)
{
EditorUtility.DisplayCancelableProgressBar("Working", "Collecting references...", 0f);
ComponentSerialization.ClearReferences();
var objects = Selection.GetFiltered(typeof(Object), SelectionMode.DeepAssets);
var components = new System.Collections.Generic.HashSet <string>();
foreach (var obj in objects)
{
if (obj is MonoScript)
{
var s = obj.name;
if (!components.Contains(s))
{
components.Add(s);
}
continue;
}
var go = obj as GameObject;
if (go)
{
go.CollectReferencedPrefabs(true);
var comps = go.GetComponentsInChildren <MonoBehaviour>(true);
foreach (var comp in comps)
{
var t = comp.GetType().ToString();
if (!components.Contains(t))
{
components.Add(t);
}
}
}
else
{
ComponentSerialization.AddReference(obj);
}
}
EditorUtility.DisplayCancelableProgressBar("Working", "Copying scripts...", 0f);
var dir = Tools.GetDirectoryFromPath(path);
// Copy the scripts
foreach (var c in components)
{
var fn = c + ".cs";
var p = Tools.FindFile(Application.dataPath, fn);
if (!string.IsNullOrEmpty(p))
{
System.IO.File.Copy(p, System.IO.Path.Combine(dir, fn), true);
}
}
EditorUtility.DisplayCancelableProgressBar("Working", "Creating a DataNode...", 0f);
foreach (var pair in ComponentSerialization.referencedPrefabs)
{
pair.Value.CollectReferencedResources();
}
var data = ComponentSerialization.SerializeBundle();
if (data != null && data.children.size > 0)
{
Save(data, path, type);
}
else
{
Debug.LogWarning("No assets found to serialize");
}
ComponentSerialization.ClearReferences();
EditorUtility.ClearProgressBar();
}
