public void StartDraining(Action onRequestsDrained) { if (_allPendingRequests.IsEmpty()) { onRequestsDrained?.Invoke(); return; } _draining = true; _onRequestsDrained = onRequestsDrained; }
void NotifyTermination(int id) { ids.TryRemove(id); if (ids.IsEmpty()) { if (uiCanvas != null) { uiCanvas.Hide(); } else { InvokeAndClearShownActionList(); } } }
public virtual void TestListDirectory() { FilePath dir = new FilePath("testListDirectory"); Files.CreateDirectory(dir.ToPath()); try { ICollection <string> entries = new HashSet <string>(); entries.AddItem("entry1"); entries.AddItem("entry2"); entries.AddItem("entry3"); foreach (string entry in entries) { Files.CreateDirectory(new FilePath(dir, entry).ToPath()); } IList <string> list = IOUtils.ListDirectory(dir, TestIOUtils.NoEntry3Filter.Instance ); foreach (string entry_1 in list) { Assert.True(entries.Remove(entry_1)); } Assert.True(entries.Contains("entry3")); list = IOUtils.ListDirectory(dir, null); foreach (string entry_2 in list) { entries.Remove(entry_2); } Assert.True(entries.IsEmpty()); } finally { FileUtils.DeleteDirectory(dir); } }
/// <summary> /// The set is connected if the set of points are neighbor-connected, and isNeighborsConnected return true for each /// two neighbors in the set.Two points are connected if they are neighbors, or one point has /// a neighbor that is neighbor-connected with the other point. /// /// Another way to put this is, this function returns true if there is a set that connects point1 /// to point2. /// </summary> /// <example> /// Checks whether the two points are connected by color. /// <code> /// IsConnected(grid, p1, p2, (p, q) => grid[p].Color == grid[q].Color) /// </code> /// </example> /// <typeparam name="TCell">The type of cell of the grid that this algorithm takes.</typeparam> /// <typeparam name="TPoint">The type of point of the grid that this algorithm takes.</typeparam> /// <param name="grid">The grid on which to do the check</param> /// <param name="point1">The first point to check.</param> /// <param name="point2">The second point to check.</param> /// <param name="getAllNeighbors">The function to use to get all neighbors of the grid.</param> /// <param name="isNeighborsConnected">The function to use to check whether two neighbors are connected.</param> /// <returns>Returns true if the two points are in a connected set.</returns> public static bool IsConnected <TPoint, TCell>( IGrid <TPoint, TCell> grid, TPoint point1, TPoint point2, Func <TPoint, IEnumerable <TPoint> > getAllNeighbors, Func <TPoint, TPoint, bool> isNeighborsConnected) { var openSet = new HashSet <TPoint>() { point1 }; var closedSet = new HashSet <TPoint>(); while (!openSet.IsEmpty()) { var current = openSet.First(); if (current.Equals(point2)) { return(true); } openSet.Remove(current); closedSet.Add(current); var connectedNeighbors = from neighbor in getAllNeighbors(current).In(grid) where !closedSet.Contains(neighbor) && isNeighborsConnected(current, neighbor) select neighbor; openSet.AddRange(connectedNeighbors); } return(false); }
/// <summary> /// TODO: @herman /// </summary> /// <typeparam name="TCell">The type of cell of the grid that this algorithm takes.</typeparam> /// <typeparam name="TPoint">The type of point of the grid that this algorithm takes.</typeparam> /// <param name="grid">The grid from which to get the connected set.</param> /// <param name="point">Point where the check start.</param> /// <param name="getConnectedPoints">This function is used to get the connected Points.</param> /// <returns>Returns a list of points connected to the given point.</returns> // TODO to Explicit shape public static HashSet <TPoint> GetConnectedSet <TCell, TPoint>( IGrid <TPoint, TCell> grid, TPoint point, Func <TPoint, IEnumerable <TPoint> > getConnectedPoints) { var openSet = new HashSet <TPoint>() { point }; var closedSet = new HashSet <TPoint>(); while (!openSet.IsEmpty()) { var current = openSet.First(); openSet.Remove(current); closedSet.Add(current); var connectedNeighbors = from neighbor in getConnectedPoints(current).In(grid) where !closedSet.Contains(neighbor) select neighbor; openSet.AddRange(connectedNeighbors); } return(closedSet); }
/** * Returns a list of points connected to the given point. * * @param isNeighborsConnected The function to use to check whether two neighbors are connected * * @tparam TCell the type of cell of the grid that this algorithm takes. * @tparam TPoint the type of point of the grid that this algorithm takes. */ public static HashSet <TPoint> GetConnectedSet <TCell, TPoint>( IGrid <TCell, TPoint> grid, TPoint point, Func <TPoint, TPoint, bool> isNeighborsConnected) where TPoint : IGridPoint <TPoint> { var openSet = new HashSet <TPoint>(new PointComparer <TPoint>()) { point }; var closedSet = new HashSet <TPoint>(new PointComparer <TPoint>()); while (!openSet.IsEmpty()) { var current = openSet.First(); openSet.Remove(current); closedSet.Add(current); var connectedNeighbors = from neighbor in grid.GetNeighbors(current) where !closedSet.Contains(neighbor) && isNeighborsConnected(current, neighbor) select neighbor; openSet.AddRange(connectedNeighbors); } return(closedSet); }
/** * Returns true if the collection of points are connected. The set is connected if * the set of points are neighbor-connected, and isNeighborsConnected return true for each * two neighbors in the set. Two points are connected if they are neighbors, or one point has * a neighbor that is neighbor-connected with the other point. * * @param grid the grid on which to do the check * @param points the set of points to check. It is assumed all points are in the grid. * @param isNeighborsConnected the function to use to check whether two neighbors are connected * * @tparam TCell the type of cell of the grid that this algorithm takes. * @tparam TPoint the type of point of the grid that this algorithm takes. * * Example: * //checks whether the list of points are connected by color. * IsConnected(grid, points, (p, q) => grid[p].Color == grid[q].Color) * */ //TODO: what should be done about points not in the grid? public static bool IsConnected <TCell, TPoint>( IGrid <TCell, TPoint> grid, IEnumerable <TPoint> points, Func <TPoint, TPoint, bool> isNeighborsConnected) where TPoint : IGridPoint <TPoint> { //What if collection is empty? var openSet = new HashSet <TPoint>(new PointComparer <TPoint>()); var closedSet = new HashSet <TPoint>(new PointComparer <TPoint>()); openSet.Add(points.First()); while (!openSet.IsEmpty()) { var current = openSet.First(); openSet.Remove(current); closedSet.Add(current); //Adds all connected neighbors that //are in the grid and in the collection var connectedNeighbors = from neighbor in grid.GetNeighbors(current) where !closedSet.Contains(neighbor) && isNeighborsConnected(current, neighbor) && points.Contains(neighbor) select neighbor; openSet.AddRange(connectedNeighbors); } return(points.All(closedSet.Contains)); }
public static bool ContainsAll <T>(this IEnumerable <T> collection, params T[] args) where T : IComparable <T> { collection.ThrowIfNull("The passed collection cannot be null."); args.ThrowIfNull("The passed arguments cannot be null."); var collectionHashSet = new HashSet <T>(collection); var argsHashSet = new HashSet <T>(args); if (collectionHashSet.Count() < argsHashSet.Count()) { foreach (var item in argsHashSet) { collectionHashSet.Remove(item); } return(collection.IsEmpty()); } foreach (var item in collectionHashSet) { argsHashSet.Remove(item); } return(argsHashSet.IsEmpty()); }
/// <summary>Add multiple node labels to repository</summary> /// <param name="labels">new node labels added</param> /// <exception cref="System.IO.IOException"/> public virtual void AddToCluserNodeLabels(ICollection <string> labels) { if (!nodeLabelsEnabled) { Log.Error(NodeLabelsNotEnabledErr); throw new IOException(NodeLabelsNotEnabledErr); } if (null == labels || labels.IsEmpty()) { return; } ICollection <string> newLabels = new HashSet <string>(); labels = NormalizeLabels(labels); // do a check before actual adding them, will throw exception if any of them // doesn't meet label name requirement foreach (string label in labels) { CheckAndThrowLabelName(label); } foreach (string label_1 in labels) { // shouldn't overwrite it to avoid changing the Label.resource if (this.labelCollections[label_1] == null) { this.labelCollections[label_1] = new NodeLabel(label_1); newLabels.AddItem(label_1); } } if (null != dispatcher && !newLabels.IsEmpty()) { dispatcher.GetEventHandler().Handle(new StoreNewClusterNodeLabels(newLabels)); } Log.Info("Add labels: [" + StringUtils.Join(labels.GetEnumerator(), ",") + "]"); }
public virtual void Predict(ICollection<string> predictedRelationsRaw, ICollection<string> goldRelationsRaw) { ICollection<string> predictedRelations = new HashSet<string>(predictedRelationsRaw); predictedRelations.Remove(KBPRelationExtractorConstants.NoRelation); ICollection<string> goldRelations = new HashSet<string>(goldRelationsRaw); goldRelations.Remove(KBPRelationExtractorConstants.NoRelation); // Register the prediction foreach (string pred in predictedRelations) { if (goldRelations.Contains(pred)) { correctCount.IncrementCount(pred); } predictedCount.IncrementCount(pred); } goldRelations.ForEach(null); HashSet<string> allRelations = new HashSet<string>(); Sharpen.Collections.AddAll(allRelations, predictedRelations); Sharpen.Collections.AddAll(allRelations, goldRelations); allRelations.ForEach(null); // Register the confusion matrix if (predictedRelations.Count == 1 && goldRelations.Count == 1) { confusion.Add(predictedRelations.GetEnumerator().Current, goldRelations.GetEnumerator().Current); } if (predictedRelations.Count == 1 && goldRelations.IsEmpty()) { confusion.Add(predictedRelations.GetEnumerator().Current, "NR"); } if (predictedRelations.IsEmpty() && goldRelations.Count == 1) { confusion.Add("NR", goldRelations.GetEnumerator().Current); } }
private void Save() { HashSet <GameObject> prefabs = new HashSet <GameObject>(); foreach (var pair in mod) { pair.Key.textKey = pair.Value; EditorUtil.SetDirty(pair.Key); GameObject p = PrefabUtility.FindPrefabRoot(pair.Key.gameObject); if (p != null) { prefabs.Add(p); } } mod.Clear(); if (!prefabs.IsEmpty()) { foreach (GameObject p in prefabs) { PrefabUtility.ReplacePrefab(p, PrefabUtility.GetCorrespondingObjectFromSource(p), ReplacePrefabOptions.ConnectToPrefab); } AssetDatabase.SaveAssets(); EditorSceneManager.SaveOpenScenes(); } }
public virtual void RemoveOrTrackCompletedContainersFromContext(IList <ContainerId > containerIds) { ICollection <ContainerId> removedContainers = new HashSet <ContainerId>(); Sharpen.Collections.AddAll(pendingContainersToRemove, containerIds); IEnumerator <ContainerId> iter = pendingContainersToRemove.GetEnumerator(); while (iter.HasNext()) { ContainerId containerId = iter.Next(); // remove the container only if the container is at DONE state Org.Apache.Hadoop.Yarn.Server.Nodemanager.Containermanager.Container.Container nmContainer = context.GetContainers()[containerId]; if (nmContainer == null) { iter.Remove(); } else { if (nmContainer.GetContainerState().Equals(ContainerState.Done)) { Sharpen.Collections.Remove(context.GetContainers(), containerId); removedContainers.AddItem(containerId); iter.Remove(); } } } if (!removedContainers.IsEmpty()) { Log.Info("Removed completed containers from NM context: " + removedContainers); } pendingCompletedContainers.Clear(); }
public void IsEmpty_Returns_True_When_Generic_HashSet_Is_Not_Null_But_Empty() { HashSet <string> testValue = new HashSet <string>(); bool result = testValue.IsEmpty(); Assert.True(result); }
public void TestSetBehavior() { ISet<InterchangeablePair<EventBean, EventBean>> eventPairs = new HashSet<InterchangeablePair<EventBean, EventBean>>(); EventBean[] events = new EventBean[4]; for (int i = 0; i < events.Length; i++) { events[i] = SupportEventBeanFactory.CreateObject( supportEventTypeFactory, new SupportBean("E" + i, i)); } eventPairs.Add(new InterchangeablePair<EventBean, EventBean>(events[0], events[1])); eventPairs.Add(new InterchangeablePair<EventBean, EventBean>(events[0], events[2])); eventPairs.Add(new InterchangeablePair<EventBean, EventBean>(events[1], events[2])); Assert.AreEqual(3, eventPairs.Count); eventPairs.Add(new InterchangeablePair<EventBean, EventBean>(events[0], events[1])); eventPairs.Add(new InterchangeablePair<EventBean, EventBean>(events[1], events[2])); eventPairs.Add(new InterchangeablePair<EventBean, EventBean>(events[2], events[0])); eventPairs.Add(new InterchangeablePair<EventBean, EventBean>(events[2], events[1])); eventPairs.Add(new InterchangeablePair<EventBean, EventBean>(events[1], events[0])); Assert.AreEqual(3, eventPairs.Count); Assert.IsTrue(eventPairs.Contains(new InterchangeablePair<EventBean, EventBean>(events[1], events[0]))); Assert.IsFalse(eventPairs.Contains(new InterchangeablePair<EventBean, EventBean>(events[3], events[0]))); Assert.IsTrue(eventPairs.Contains(new InterchangeablePair<EventBean, EventBean>(events[1], events[2]))); Assert.IsTrue(eventPairs.Contains(new InterchangeablePair<EventBean, EventBean>(events[2], events[0]))); eventPairs.Remove(new InterchangeablePair<EventBean, EventBean>(events[2], events[0])); Assert.IsFalse(eventPairs.Contains(new InterchangeablePair<EventBean, EventBean>(events[2], events[0]))); eventPairs.Remove(new InterchangeablePair<EventBean, EventBean>(events[1], events[2])); eventPairs.Remove(new InterchangeablePair<EventBean, EventBean>(events[1], events[0])); Assert.IsTrue(eventPairs.IsEmpty()); }
private static bool ContainsAnyImplementation(string source, IEnumerable<char> characters) { Debug.Assert(source != null, "source != null"); Debug.Assert(characters != null, "characters != null"); var hs = new HashSet<char>(characters); return !hs.IsEmpty() && source.Any(hs.Contains); }
public static bool IsEquivalentTo <T>(this IEnumerable <T> source, IEnumerable <T> other, IEqualityComparer <T> comparer = null) { var set = new HashSet <T>(source, comparer ?? EqualityComparer <T> .Default); set.SymmetricExceptWith(other); return(set.IsEmpty()); }
public void RemoveLevel(BindingLevel level) { _levels.Remove(level); if (_levels.IsEmpty()) { Clear(); } }
static void Main(string[] args) { HashSet <int> set = new HashSet <int>(); set.AddRange(new[] { 2, 3, 4, 4 }); Console.WriteLine(set.IsEmpty()); Console.WriteLine(string.Join(" ", set)); }
public void IsEmpty_Returns_False_When_Generic_HashSet_Is_Not_Null_And_Not_Empty() { HashSet <string> testValue = new HashSet <string>(); testValue.Add("test"); bool result = testValue.IsEmpty(); Assert.False(result); }
/// <exception cref="System.IO.IOException"></exception> private ObjectDirectory.CachedPackList ScanCachedPacks(ObjectDirectory.CachedPackList old) { FileSnapshot s = FileSnapshot.Save(cachedPacksFile); byte[] buf; try { buf = IOUtil.ReadFully(cachedPacksFile); } catch (FileNotFoundException) { buf = new byte[0]; } if (old != null && old.snapshot.Equals(s) && Arrays.Equals(old.raw, buf)) { old.snapshot.SetClean(s); return(old); } AList <LocalCachedPack> list = new AList <LocalCachedPack>(4); ICollection <ObjectId> tips = new HashSet <ObjectId>(); int ptr = 0; while (ptr < buf.Length) { if (buf[ptr] == '#' || buf[ptr] == '\n') { ptr = RawParseUtils.NextLF(buf, ptr); continue; } if (buf[ptr] == '+') { tips.AddItem(ObjectId.FromString(buf, ptr + 2)); ptr = RawParseUtils.NextLF(buf, ptr + 2); continue; } IList <string> names = new AList <string>(4); while (ptr < buf.Length && buf[ptr] == 'P') { int end = RawParseUtils.NextLF(buf, ptr); if (buf[end - 1] == '\n') { end--; } names.AddItem(RawParseUtils.Decode(buf, ptr + 2, end)); ptr = RawParseUtils.NextLF(buf, end); } if (!tips.IsEmpty() && !names.IsEmpty()) { list.AddItem(new LocalCachedPack(this, tips, names)); tips = new HashSet <ObjectId>(); } } list.TrimToSize(); return(new ObjectDirectory.CachedPackList(s, Sharpen.Collections.UnmodifiableList (list), buf)); }
public void LazyInjectAll() { while (!_instancesToInject.IsEmpty()) { var instance = _instancesToInject.First(); _instancesToInject.Remove(instance); _container.Inject(instance); } }
public virtual void TestDirectory() { fs.Mkdirs(Dir1); // test empty directory RemoteIterator <LocatedFileStatus> itor = fs.ListFiles(Dir1, true); NUnit.Framework.Assert.IsFalse(itor.HasNext()); itor = fs.ListFiles(Dir1, false); NUnit.Framework.Assert.IsFalse(itor.HasNext()); // testing directory with 1 file WriteFile(fs, File2, FileLen); itor = fs.ListFiles(Dir1, true); LocatedFileStatus stat = itor.Next(); NUnit.Framework.Assert.IsFalse(itor.HasNext()); Assert.True(stat.IsFile()); Assert.Equal(FileLen, stat.GetLen()); Assert.Equal(fs.MakeQualified(File2), stat.GetPath()); Assert.Equal(1, stat.GetBlockLocations().Length); itor = fs.ListFiles(Dir1, false); stat = itor.Next(); NUnit.Framework.Assert.IsFalse(itor.HasNext()); Assert.True(stat.IsFile()); Assert.Equal(FileLen, stat.GetLen()); Assert.Equal(fs.MakeQualified(File2), stat.GetPath()); Assert.Equal(1, stat.GetBlockLocations().Length); // test more complicated directory WriteFile(fs, File1, FileLen); WriteFile(fs, File3, FileLen); ICollection <Path> filesToFind = new HashSet <Path>(); filesToFind.AddItem(fs.MakeQualified(File1)); filesToFind.AddItem(fs.MakeQualified(File2)); filesToFind.AddItem(fs.MakeQualified(File3)); itor = fs.ListFiles(TestDir, true); stat = itor.Next(); Assert.True(stat.IsFile()); Assert.True("Path " + stat.GetPath() + " unexpected", filesToFind .Remove(stat.GetPath())); stat = itor.Next(); Assert.True(stat.IsFile()); Assert.True("Path " + stat.GetPath() + " unexpected", filesToFind .Remove(stat.GetPath())); stat = itor.Next(); Assert.True(stat.IsFile()); Assert.True("Path " + stat.GetPath() + " unexpected", filesToFind .Remove(stat.GetPath())); NUnit.Framework.Assert.IsFalse(itor.HasNext()); Assert.True(filesToFind.IsEmpty()); itor = fs.ListFiles(TestDir, false); stat = itor.Next(); Assert.True(stat.IsFile()); Assert.Equal(fs.MakeQualified(File1), stat.GetPath()); NUnit.Framework.Assert.IsFalse(itor.HasNext()); fs.Delete(TestDir, true); }
public override IEnumerable <FileGroup> ScanDirectories(CancellationToken token) { var existingGroups = new HashSet <string>(GetGroups().Where(@group => group != _files).Select(@group => group.Name)); IEnumerable <DirectoryTreeFileGroup> fileGroups = _directoryInfo.EnumerateDirectories() .Where(info => info.Name != ".picasaoriginals") .Where(info => !existingGroups.Remove(info.Name)) .Select(info => new DirectoryTreeFileGroup(info.Name, info)); var groups = new List <FileGroup>(); foreach (DirectoryTreeFileGroup fileGroup in fileGroups) { token.ThrowIfCancellationRequested(); groups.Add(fileGroup); } AddGroups(groups); if (!existingGroups.IsEmpty()) { RemoveGroups(existingGroups); } var existingFiles = new HashSet <string>(_files.GetFiles().Select(file => file.FileName)); IEnumerable <PictureFile.PictureFile> pictureFiles = PictureFile.PictureFile.FileNamePatterns.SelectMany(pattern => _directoryInfo.EnumerateFiles(pattern)) .Distinct(new CompareFileNames()) .Where(info => !info.Name.StartsWith("._")) .Where(info => !existingFiles.Remove(info.FullName)) .Select(info => new PictureFile.PictureFile(info)); var files = new List <PictureFile.PictureFile>(); foreach (PictureFile.PictureFile pictureFile in pictureFiles) { token.ThrowIfCancellationRequested(); files.Add(pictureFile); if (files.Count > 999) { _files.AddFiles(files); files = new List <PictureFile.PictureFile>(); } } if (!files.IsEmpty()) { _files.AddFiles(files); } if (!existingFiles.IsEmpty()) { _files.RemoveFiles(existingFiles); } return(GetGroups()); }
public async Task <IEnumerable <ApiResource> > FindApiResourcesByNameAsync(IEnumerable <string> apiResourceNames) { var names = new HashSet <string>(apiResourceNames); var apiResources = new List <ApiResource>(); if (!names.IsEmpty()) { apiResources.AddRange(_resources.ApiResources.Where(r => names.Contains(r.Name, StringComparer.Ordinal))); } return(await Task.FromResult(apiResources)); }
public async Task <IEnumerable <IdentityResource> > FindIdentityResourcesByScopeNameAsync( IEnumerable <string> scopeNames) { var names = new HashSet <string>(scopeNames); var resources = new List <IdentityResource>(); if (!names.IsEmpty()) { resources.AddRange(_resources.IdentityResources.Where(r => names.Contains(r.Name, StringComparer.Ordinal))); } return(await Task.FromResult(resources)); }
public virtual void TestNullKeys() { JobConf conf = new JobConf(typeof(TestMapRed)); FileSystem fs = FileSystem.GetLocal(conf); HashSet <string> values = new HashSet <string>(); string m = "AAAAAAAAAAAAAA"; for (int i = 1; i < 11; ++i) { values.AddItem(m); m = m.Replace((char)('A' + i - 1), (char)('A' + i)); } Path testdir = new Path(Runtime.GetProperty("test.build.data", "/tmp")).MakeQualified (fs); fs.Delete(testdir, true); Path inFile = new Path(testdir, "nullin/blah"); SequenceFile.Writer w = SequenceFile.CreateWriter(fs, conf, inFile, typeof(NullWritable ), typeof(Text), SequenceFile.CompressionType.None); Text t = new Text(); foreach (string s in values) { t.Set(s); w.Append(NullWritable.Get(), t); } w.Close(); FileInputFormat.SetInputPaths(conf, inFile); FileOutputFormat.SetOutputPath(conf, new Path(testdir, "nullout")); conf.SetMapperClass(typeof(TestMapRed.NullMapper)); conf.SetReducerClass(typeof(IdentityReducer)); conf.SetOutputKeyClass(typeof(NullWritable)); conf.SetOutputValueClass(typeof(Text)); conf.SetInputFormat(typeof(SequenceFileInputFormat)); conf.SetOutputFormat(typeof(SequenceFileOutputFormat)); conf.SetNumReduceTasks(1); conf.Set(MRConfig.FrameworkName, MRConfig.LocalFrameworkName); JobClient.RunJob(conf); // Since null keys all equal, allow any ordering SequenceFile.Reader r = new SequenceFile.Reader(fs, new Path(testdir, "nullout/part-00000" ), conf); m = "AAAAAAAAAAAAAA"; for (int i_1 = 1; r.Next(NullWritable.Get(), t); ++i_1) { NUnit.Framework.Assert.IsTrue("Unexpected value: " + t, values.Remove(t.ToString( ))); m = m.Replace((char)('A' + i_1 - 1), (char)('A' + i_1)); } NUnit.Framework.Assert.IsTrue("Missing values: " + values.ToString(), values.IsEmpty ()); }
// what are the dependencies that the given deployment provides to other modules? public static EPDeploymentDependencyProvided GetDependenciesProvided( string selfDeploymentId, EPServicesPath paths, DeploymentLifecycleService deploymentLifecycleService) { DeploymentInternal selfDeployment = deploymentLifecycleService.GetDeploymentById(selfDeploymentId); if (selfDeployment == null) { return(null); } IList <EPDeploymentDependencyProvided.Item> dependencies = new List <EPDeploymentDependencyProvided.Item>(4); string moduleName = selfDeployment.ModuleProvider.ModuleName; HandleProvided(selfDeployment.PathNamedWindows, EPObjectType.NAMEDWINDOW, paths.NamedWindowPathRegistry, moduleName, dependencies, name => name); HandleProvided(selfDeployment.PathTables, EPObjectType.TABLE, paths.TablePathRegistry, moduleName, dependencies, name => name); HandleProvided(selfDeployment.PathVariables, EPObjectType.VARIABLE, paths.VariablePathRegistry, moduleName, dependencies, name => name); HandleProvided(selfDeployment.PathContexts, EPObjectType.CONTEXT, paths.ContextPathRegistry, moduleName, dependencies, name => name); HandleProvided(selfDeployment.PathEventTypes, EPObjectType.EVENTTYPE, paths.EventTypePathRegistry, moduleName, dependencies, name => name); HandleProvided(selfDeployment.PathExprDecls, EPObjectType.EXPRESSION, paths.ExprDeclaredPathRegistry, moduleName, dependencies, name => name); HandleProvided(selfDeployment.PathScripts, EPObjectType.SCRIPT, paths.ScriptPathRegistry, moduleName, dependencies, SCRIPT_OBJECTNAME); HandleProvided( selfDeployment.PathClassProvideds, EPObjectType.CLASSPROVIDED, paths.ClassProvidedPathRegistry, moduleName, dependencies, name => name); foreach (ModuleIndexMeta objectName in selfDeployment.PathIndexes) { EventTableIndexMetadata indexMetadata = GetIndexMetadata(objectName, moduleName, paths); if (indexMetadata == null) { continue; } EventTableIndexMetadataEntry meta = indexMetadata.GetIndexEntryByName(objectName.IndexName); if (meta != null && meta.ReferringDeployments != null && meta.ReferringDeployments.Length > 0) { ISet <string> referred = new HashSet <string>(Arrays.AsList(meta.ReferringDeployments)); referred.Remove(selfDeploymentId); if (!referred.IsEmpty()) { dependencies.Add(new EPDeploymentDependencyProvided.Item(EPObjectType.INDEX, INDEX_OBJECTNAME.Invoke(objectName), referred)); } } } return(new EPDeploymentDependencyProvided(dependencies)); }
private ICollection <string> RouteDataSources(ShardingRule shardingRule, TableRule tableRule, List <IRouteValue> databaseShardingValues) { if (databaseShardingValues.IsEmpty()) { return(tableRule.GetActualDatasourceNames()); } ICollection <string> result = new HashSet <string>(shardingRule.GetDatabaseShardingStrategy(tableRule).DoSharding(tableRule.GetActualDatasourceNames(), databaseShardingValues, this.Properties)); ShardingAssert.If(result.IsEmpty(), "no database route info"); ShardingAssert.Else(tableRule.GetActualDatasourceNames().All(o => result.Contains(o)), $"Some routed data sources do not belong to configured data sources. routed data sources: `{result}`, configured data sources: `{tableRule.GetActualDatasourceNames()}`"); return(result); }
void FinishLoadingTask(int loadingTaskId, IReadOnlyList <AssetBundleRecord> necessaryAssetBundleRecords) { foreach (AssetBundleRecord assetBundleRecord in necessaryAssetBundleRecords) { string assetBundleName = assetBundleRecord.AssetBundleName; HashSet <int> taskIds = loadingTaskIdSets.GetValue(assetBundleName); if (taskIds == null) { errorReceiver.OnError(AssetBundleErrorCode.MissingTaskIdSetInTermination, $"cannot get task id set: {assetBundleName}"); return; } if (!taskIds.TryRemove(loadingTaskId)) { errorReceiver.OnError(AssetBundleErrorCode.FailureToRemoveTaskId, $"cannot remove task id: {assetBundleName}"); return; } if (taskIds.IsEmpty()) { if (!loadingTaskIdSets.TryRemove(assetBundleName)) { errorReceiver.OnError(AssetBundleErrorCode.FailureToRemoveLoadingTaskIdSet, $"cannot remove loading task id set: {assetBundleName}"); return; } HashSetPool <int> .Pool.Put(ref taskIds); AssetBundle unusingAssetBundle = loadedAssetBundles.GetValue(assetBundleName); if (unusingAssetBundle == null) { errorReceiver.OnError(AssetBundleErrorCode.MissingLoadedAssetBundle, $"cannot get loaded asset bundle: {assetBundleName}"); return; } unusingAssetBundle.Unload(false); if (!loadedAssetBundles.TryRemove(assetBundleName)) { errorReceiver.OnError(AssetBundleErrorCode.FailureToRemoveLoadedAssetBundle, $"cannot remove loaded asset bundle: {assetBundleName}"); return; } } } if (!loadingTasks.TryRemove(loadingTaskId)) { errorReceiver.OnError(AssetBundleErrorCode.FailureToRemoveLoadingTask, "cannot remove loading task"); return; } }
public IActionResult EditDepartment(string id, HashSet <string> OwnerIds, HashSet <string> userGroupIds) { string successMsg = string.Empty; string errorMsg = string.Empty; var dbDepartment = this.GetService <DepartmentService>().Get(id); if (dbDepartment == null) { errorMsg = id + "doesn't exist!"; return(RedirectDepartment(successMsg, errorMsg)); } if (!this.GetService <DepartmentService>().IsBoss(this.GetUserId(), dbDepartment.OwnerIds)) { errorMsg = "You don't have right!"; return(RedirectDepartment(successMsg, errorMsg)); } if (OwnerIds.IsEmpty()) { ViewData["Department"] = dbDepartment; ViewData["Owners"] = this.GetService <UserService>().Get(o => o.UserType == UserType.Manager); ViewData["UserGroups"] = this.GetService <DepartmentService>().GetUserGroupsByOwnerId(this.GetUserId()); return(View()); } else { try { dbDepartment.OwnerIds = OwnerIds; var removeUserGroupIds = dbDepartment.UserGroups.Keys.Except(userGroupIds).ToList(); foreach (var item in removeUserGroupIds) { dbDepartment.UserGroups.Remove(item); } this.GetService <DepartmentService>().Update(dbDepartment); successMsg = string.Format("Edit department({0}) successfully!", id); } catch (Exception ex) { errorMsg = ex.Message; } return(RedirectDepartment(successMsg, errorMsg)); } }
public virtual ICollection <EventType> GetSupportedEvents() { ICollection <EventType> evts = new HashSet <EventType>(); foreach (ILocationExtractionStrategy s in strategies) { ICollection <EventType> se = s.GetSupportedEvents(); if (se != null) { evts.AddAll(se); } } return(evts.IsEmpty() ? null : evts); }
/// <summary> /// Creates a new compilation without the specified syntax trees. Preserves metadata info for use with trees /// added later. /// </summary> public new CSharpCompilation RemoveSyntaxTrees(IEnumerable<SyntaxTree> trees) { using (Logger.LogBlock(FunctionId.CSharp_Compilation_RemoveSyntaxTrees, message: this.AssemblyName)) { if (trees == null) { throw new ArgumentNullException("trees"); } if (trees.IsEmpty()) { return this; } bool referenceDirectivesChanged = false; var removeSet = new HashSet<SyntaxTree>(); var declMap = rootNamespaces; var declTable = declarationTable; foreach (var tree in trees.Cast<CSharpSyntaxTree>()) { RemoveSyntaxTreeFromDeclarationMapAndTable(tree, ref declMap, ref declTable, ref referenceDirectivesChanged); removeSet.Add(tree); } Debug.Assert(!removeSet.IsEmpty()); // We're going to have to revise the ordinals of all // trees after the first one removed, so just build // a new map. var ordinalMap = ImmutableDictionary.Create<SyntaxTree, int>(); var builder = ArrayBuilder<SyntaxTree>.GetInstance(); int i = 0; foreach (var tree in this.SyntaxTrees) { if (!removeSet.Contains(tree)) { builder.Add(tree); ordinalMap = ordinalMap.Add(tree, i++); } } return UpdateSyntaxTrees(builder.ToImmutableAndFree(), ordinalMap, declMap, declTable, referenceDirectivesChanged); } }
/// <summary> /// Expansion Algorithm /// http://json-ld.org/spec/latest/json-ld-api/#expansion-algorithm /// </summary> /// <param name="activeCtx"></param> /// <param name="activeProperty"></param> /// <param name="element"></param> /// <returns></returns> /// <exception cref="JsonLdError">JsonLdError</exception> /// <exception cref="JsonLD.Core.JsonLdError"></exception> public virtual JToken Expand(Context activeCtx, string activeProperty, JToken element ) { // 1) if (element.IsNull()) { return null; } // 3) if (element is JArray) { // 3.1) JArray result = new JArray(); // 3.2) foreach (JToken item in (JArray)element) { // 3.2.1) JToken v = Expand(activeCtx, activeProperty, item); // 3.2.2) if (("@list".Equals(activeProperty) || "@list".Equals(activeCtx.GetContainer(activeProperty ))) && (v is JArray || (v is JObject && ((IDictionary<string, JToken>)v).ContainsKey ("@list")))) { throw new JsonLdError(JsonLdError.Error.ListOfLists, "lists of lists are not permitted." ); } else { // 3.2.3) if (!v.IsNull()) { if (v is JArray) { JsonLD.Collections.AddAll(result, (JArray)v); } else { result.Add(v); } } } } // 3.3) return result; } else { // 4) if (element is JObject) { // access helper IDictionary<string, JToken> elem = (JObject)element; // 5) if (elem.ContainsKey("@context")) { activeCtx = activeCtx.Parse(elem["@context"]); } // 6) JObject result = new JObject(); // 7) JArray keys = new JArray(element.GetKeys()); keys.SortInPlace(); foreach (string key in keys) { JToken value = elem[key]; // 7.1) if (key.Equals("@context")) { continue; } // 7.2) string expandedProperty = activeCtx.ExpandIri(key, false, true, null, null); JToken expandedValue = null; // 7.3) if (expandedProperty == null || (!expandedProperty.Contains(":") && !JsonLdUtils.IsKeyword (expandedProperty))) { continue; } // 7.4) if (JsonLdUtils.IsKeyword(expandedProperty)) { // 7.4.1) if ("@reverse".Equals(activeProperty)) { throw new JsonLdError(JsonLdError.Error.InvalidReversePropertyMap, "a keyword cannot be used as a @reverse propery" ); } // 7.4.2) if (result.ContainsKey(expandedProperty)) { throw new JsonLdError(JsonLdError.Error.CollidingKeywords, expandedProperty + " already exists in result" ); } // 7.4.3) if ("@id".Equals(expandedProperty)) { if (!(value.Type == JTokenType.String)) { throw new JsonLdError(JsonLdError.Error.InvalidIdValue, "value of @id must be a string" ); } expandedValue = activeCtx.ExpandIri((string)value, true, false, null, null); } else { // 7.4.4) if ("@type".Equals(expandedProperty)) { if (value is JArray) { expandedValue = new JArray(); foreach (JToken v in (JArray)value) { if (v.Type != JTokenType.String) { throw new JsonLdError(JsonLdError.Error.InvalidTypeValue, "@type value must be a string or array of strings" ); } ((JArray)expandedValue).Add(activeCtx.ExpandIri((string)v, true, true, null , null)); } } else { if (value.Type == JTokenType.String) { expandedValue = activeCtx.ExpandIri((string)value, true, true, null, null); } else { // TODO: SPEC: no mention of empty map check if (value is JObject) { if (((JObject)value).Count != 0) { throw new JsonLdError(JsonLdError.Error.InvalidTypeValue, "@type value must be a an empty object for framing" ); } expandedValue = value; } else { throw new JsonLdError(JsonLdError.Error.InvalidTypeValue, "@type value must be a string or array of strings" ); } } } } else { // 7.4.5) if ("@graph".Equals(expandedProperty)) { expandedValue = Expand(activeCtx, "@graph", value); } else { // 7.4.6) if ("@value".Equals(expandedProperty)) { if (!value.IsNull() && (value is JObject || value is JArray)) { throw new JsonLdError(JsonLdError.Error.InvalidValueObjectValue, "value of " + expandedProperty + " must be a scalar or null"); } expandedValue = value; if (expandedValue.IsNull()) { result["@value"] = null; continue; } } else { // 7.4.7) if ("@language".Equals(expandedProperty)) { if (!(value.Type == JTokenType.String)) { throw new JsonLdError(JsonLdError.Error.InvalidLanguageTaggedString, "Value of " + expandedProperty + " must be a string"); } expandedValue = ((string)value).ToLower(); } else { // 7.4.8) if ("@index".Equals(expandedProperty)) { if (!(value.Type == JTokenType.String)) { throw new JsonLdError(JsonLdError.Error.InvalidIndexValue, "Value of " + expandedProperty + " must be a string"); } expandedValue = value; } else { // 7.4.9) if ("@list".Equals(expandedProperty)) { // 7.4.9.1) if (activeProperty == null || "@graph".Equals(activeProperty)) { continue; } // 7.4.9.2) expandedValue = Expand(activeCtx, activeProperty, value); // NOTE: step not in the spec yet if (!(expandedValue is JArray)) { JArray tmp = new JArray(); tmp.Add(expandedValue); expandedValue = tmp; } // 7.4.9.3) foreach (JToken o in (JArray)expandedValue) { if (o is JObject && ((JObject)o).ContainsKey("@list")) { throw new JsonLdError(JsonLdError.Error.ListOfLists, "A list may not contain another list" ); } } } else { // 7.4.10) if ("@set".Equals(expandedProperty)) { expandedValue = Expand(activeCtx, activeProperty, value); } else { // 7.4.11) if ("@reverse".Equals(expandedProperty)) { if (!(value is JObject)) { throw new JsonLdError(JsonLdError.Error.InvalidReverseValue, "@reverse value must be an object" ); } // 7.4.11.1) expandedValue = Expand(activeCtx, "@reverse", value); // NOTE: algorithm assumes the result is a map // 7.4.11.2) if (((IDictionary<string, JToken>)expandedValue).ContainsKey("@reverse")) { JObject reverse = (JObject)((JObject)expandedValue)["@reverse"]; foreach (string property in reverse.GetKeys()) { JToken item = reverse[property]; // 7.4.11.2.1) if (!result.ContainsKey(property)) { result[property] = new JArray(); } // 7.4.11.2.2) if (item is JArray) { JsonLD.Collections.AddAll(((JArray)result[property]), (JArray)item); } else { ((JArray)result[property]).Add(item); } } } // 7.4.11.3) if (((JObject)expandedValue).Count > (((JObject)expandedValue).ContainsKey("@reverse") ? 1 : 0)) { // 7.4.11.3.1) if (!result.ContainsKey("@reverse")) { result["@reverse"] = new JObject(); } // 7.4.11.3.2) JObject reverseMap = (JObject)result["@reverse"]; // 7.4.11.3.3) foreach (string property in expandedValue.GetKeys()) { if ("@reverse".Equals(property)) { continue; } // 7.4.11.3.3.1) JArray items = (JArray)((JObject)expandedValue)[property]; foreach (JToken item in items) { // 7.4.11.3.3.1.1) if (item is JObject && (((JObject)item).ContainsKey("@value") || ((JObject)item).ContainsKey("@list"))) { throw new JsonLdError(JsonLdError.Error.InvalidReversePropertyValue); } // 7.4.11.3.3.1.2) if (!reverseMap.ContainsKey(property)) { reverseMap[property] = new JArray(); } // 7.4.11.3.3.1.3) ((JArray)reverseMap[property]).Add(item); } } } // 7.4.11.4) continue; } else { // TODO: SPEC no mention of @explicit etc in spec if ("@explicit".Equals(expandedProperty) || "@default".Equals(expandedProperty) || "@embed".Equals(expandedProperty) || "@embedChildren".Equals(expandedProperty) || "@omitDefault".Equals(expandedProperty)) { expandedValue = Expand(activeCtx, expandedProperty, value); } } } } } } } } } } // 7.4.12) if (!expandedValue.IsNull()) { result[expandedProperty] = expandedValue; } // 7.4.13) continue; } else { // 7.5 if ("@language".Equals(activeCtx.GetContainer(key)) && value is JObject) { // 7.5.1) expandedValue = new JArray(); // 7.5.2) foreach (string language in value.GetKeys()) { JToken languageValue = ((IDictionary<string, JToken>)value)[language]; // 7.5.2.1) if (!(languageValue is JArray)) { JToken tmp = languageValue; languageValue = new JArray(); ((JArray)languageValue).Add(tmp); } // 7.5.2.2) foreach (JToken item in (JArray)languageValue) { // 7.5.2.2.1) if (!(item.Type == JTokenType.String)) { throw new JsonLdError(JsonLdError.Error.InvalidLanguageMapValue, "Expected " + item .ToString() + " to be a string"); } // 7.5.2.2.2) JObject tmp = new JObject(); tmp["@value"] = item; tmp["@language"] = language.ToLower(); ((JArray)expandedValue).Add(tmp); } } } else { // 7.6) if ("@index".Equals(activeCtx.GetContainer(key)) && value is JObject) { // 7.6.1) expandedValue = new JArray(); // 7.6.2) JArray indexKeys = new JArray(value.GetKeys()); indexKeys.SortInPlace(); foreach (string index in indexKeys) { JToken indexValue = ((JObject)value)[index]; // 7.6.2.1) if (!(indexValue is JArray)) { JToken tmp = indexValue; indexValue = new JArray(); ((JArray)indexValue).Add(tmp); } // 7.6.2.2) indexValue = Expand(activeCtx, key, indexValue); // 7.6.2.3) foreach (JObject item in (JArray)indexValue) { // 7.6.2.3.1) if (!item.ContainsKey("@index")) { item["@index"] = index; } // 7.6.2.3.2) ((JArray)expandedValue).Add(item); } } } else { // 7.7) expandedValue = Expand(activeCtx, key, value); } } } // 7.8) if (expandedValue.IsNull()) { continue; } // 7.9) if ("@list".Equals(activeCtx.GetContainer(key))) { if (!(expandedValue is JObject) || !((JObject)expandedValue).ContainsKey("@list")) { JToken tmp = expandedValue; if (!(tmp is JArray)) { tmp = new JArray(); ((JArray)tmp).Add(expandedValue); } expandedValue = new JObject(); ((JObject)expandedValue)["@list"] = tmp; } } // 7.10) if (activeCtx.IsReverseProperty(key)) { // 7.10.1) if (!result.ContainsKey("@reverse")) { result["@reverse"] = new JObject(); } // 7.10.2) JObject reverseMap = (JObject)result["@reverse"]; // 7.10.3) if (!(expandedValue is JArray)) { JToken tmp = expandedValue; expandedValue = new JArray(); ((JArray)expandedValue).Add(tmp); } // 7.10.4) foreach (JToken item in (JArray)expandedValue) { // 7.10.4.1) if (item is JObject && (((JObject)item).ContainsKey("@value") || ((JObject)item).ContainsKey("@list"))) { throw new JsonLdError(JsonLdError.Error.InvalidReversePropertyValue); } // 7.10.4.2) if (!reverseMap.ContainsKey(expandedProperty)) { reverseMap[expandedProperty] = new JArray(); } // 7.10.4.3) if (item is JArray) { JsonLD.Collections.AddAll(((JArray)reverseMap[expandedProperty]), (JArray)item); } else { ((JArray)reverseMap[expandedProperty]).Add(item); } } } else { // 7.11) // 7.11.1) if (!result.ContainsKey(expandedProperty)) { result[expandedProperty] = new JArray(); } // 7.11.2) if (expandedValue is JArray) { JsonLD.Collections.AddAll(((JArray)result[expandedProperty]), (JArray)expandedValue); } else { ((JArray)result[expandedProperty]).Add(expandedValue); } } } // 8) if (result.ContainsKey("@value")) { // 8.1) // TODO: is this method faster than just using containsKey for // each? ICollection<string> keySet = new HashSet<string>(result.GetKeys()); keySet.Remove("@value"); keySet.Remove("@index"); bool langremoved = keySet.Remove("@language"); bool typeremoved = keySet.Remove("@type"); if ((langremoved && typeremoved) || !keySet.IsEmpty()) { throw new JsonLdError(JsonLdError.Error.InvalidValueObject, "value object has unknown keys" ); } // 8.2) JToken rval = result["@value"]; if (rval.IsNull()) { // nothing else is possible with result if we set it to // null, so simply return it return null; } // 8.3) if (!(rval.Type == JTokenType.String) && result.ContainsKey("@language")) { throw new JsonLdError(JsonLdError.Error.InvalidLanguageTaggedValue, "when @language is used, @value must be a string" ); } else { // 8.4) if (result.ContainsKey("@type")) { // TODO: is this enough for "is an IRI" if (!(result["@type"].Type == JTokenType.String) || ((string)result["@type"]).StartsWith("_:") || !((string)result["@type"]).Contains(":")) { throw new JsonLdError(JsonLdError.Error.InvalidTypedValue, "value of @type must be an IRI" ); } } } } else { // 9) if (result.ContainsKey("@type")) { JToken rtype = result["@type"]; if (!(rtype is JArray)) { JArray tmp = new JArray(); tmp.Add(rtype); result["@type"] = tmp; } } else { // 10) if (result.ContainsKey("@set") || result.ContainsKey("@list")) { // 10.1) if (result.Count > (result.ContainsKey("@index") ? 2 : 1)) { throw new JsonLdError(JsonLdError.Error.InvalidSetOrListObject, "@set or @list may only contain @index" ); } // 10.2) if (result.ContainsKey("@set")) { // result becomes an array here, thus the remaining checks // will never be true from here on // so simply return the value rather than have to make // result an object and cast it with every // other use in the function. return result["@set"]; } } } } // 11) if (result.ContainsKey("@language") && result.Count == 1) { result = null; } // 12) if (activeProperty == null || "@graph".Equals(activeProperty)) { // 12.1) if (result != null && (result.Count == 0 || result.ContainsKey("@value") || result .ContainsKey("@list"))) { result = null; } else { // 12.2) if (result != null && result.ContainsKey("@id") && result.Count == 1) { result = null; } } } // 13) return result; } else { // 2) If element is a scalar // 2.1) if (activeProperty == null || "@graph".Equals(activeProperty)) { return null; } return activeCtx.ExpandValue(activeProperty, element); } } }
getFuturesStatic(List< string> tickers , string futuresStaticMoniker, ICarbonClient client, string carbonEnv, out Tuple<List<Tuple<string, ContractMonths>> /*rootTickers*/, List<string> /*contracts*/> tickerSplitTuple, DateTime? vStartDate = null, DateTime? vEndDate = null, List<string> contractSortOrder = null ) //------------------------------------------------------------------------------------------------ { // Intialisation if (tickers == null) { tickers = new List<string>(); } DateTime startDate, endDate; if (vStartDate == null) { startDate = DateTime.MinValue; } else { startDate = vStartDate.Value; } if (vStartDate == null) { endDate = DateTime.MaxValue; } else { endDate = vEndDate.Value; } if (contractSortOrder == null) { contractSortOrder = new List<string>(); } string cacheKey = getCacheKey(tickers, futuresStaticMoniker, startDate, endDate, contractSortOrder); // Divide inputs according to whether they should be used for rolling futures or not tickerSplitTuple = splitRollingFuturesFromRawTickers(tickers); List<string> contractTickers = tickerSplitTuple.Item2; List<Tuple<string, ContractMonths>> rootTickers = tickerSplitTuple.Item1; // Get Static From cache here if we have it, tickersplittuple has been set. Frame<string, string> cachedValue; if (StaticCache_.TryGetValue(cacheKey, out cachedValue)) return cachedValue; // Get all the roots from list List< string> rollingFuturesIDs = new List<string>(); foreach (var tup in rootTickers) { rollingFuturesIDs.Add(tup.Item1); } // Get test sets. // This allows us to map back names used in futures static moniker, to our original inputs var bbgTickerMap = processBBGTickerList(contractTickers); HashSet<string> rollingSet = new HashSet<string>(rollingFuturesIDs); HashSet<string> tickerSet = new HashSet<string>(bbgTickerMap.Keys.AsEnumerable()); // Processing inputs Frame<string, string> output; var rowList = new List<KeyValuePair<int/*id*/, Series<string, object>/*row*/>>(); var df = client.GetDataFrame(futuresStaticMoniker); var tmp = df.ToList(); var col = tmp[0].Value as List<object>; var ind = tmp[1].Value as List<object>; var dat = tmp[2].Value as List<object>; //Find it's first trade date col int firstTradeDtCol = 0; int futDeliveryDtCol = 0; int typeCol = 0; for (int j = 0; j < col.Count; ++j) { string heading = col[j].ToString(); if (heading == "fut_first_trade_dt") { firstTradeDtCol = j; } if (heading == "fut_dlv_dt_last") { futDeliveryDtCol = j; } if(heading == "type") { typeCol = j; } } //client.getdat SeriesBuilder<string> sb; int i; for (i = 0; i < ind.Count; ++i) { sb = new SeriesBuilder<string>(); var data = dat[i] as List<object>; var contract = data[typeCol].ToString(); string index = (string)ind[i]; if ((tickerSet.IsEmpty() && rollingSet.IsEmpty()) || (!tickerSet.Contains(index) && !rollingSet.Contains(contract))) { continue; } DateTime firstTradeDate = DateTime.ParseExact(data[firstTradeDtCol].ToString(), "%dd/%MM/%yyyy", CultureInfo.InvariantCulture); DateTime futDeliveryDate = DateTime.ParseExact(data[futDeliveryDtCol].ToString(), "%dd/%MM/%yyyy", CultureInfo.InvariantCulture); if (rollingSet.Contains(contract) && (futDeliveryDate < startDate || firstTradeDate > endDate)) { continue; } if (bbgTickerMap.ContainsKey(index)) sb.Add("ticker", bbgTickerMap[index]); else sb.Add("ticker", index); // ignores the mappings, in the rolling contract case for (int h = 0; h < col.Count; ++h) { sb.Add((string)col[h], data[h]); } rowList.Add(KeyValue.Create(i, sb.Series)); } output = Frame.FromRows(rowList).IndexRows<string>("ticker", keepColumn: true); if (rootTickers.IsEmpty()) { output = sortFrameByInput(output, tickers); } else { output = sortFrameByNaturalOrder(output, contractSortOrder); } StaticCache_.TryAdd(cacheKey, output.Clone()); return output; }
/// <exception cref="System.IO.IOException"></exception> private ObjectDirectory.CachedPackList ScanCachedPacks(ObjectDirectory.CachedPackList old) { FileSnapshot s = FileSnapshot.Save(cachedPacksFile); byte[] buf; try { buf = IOUtil.ReadFully(cachedPacksFile); } catch (FileNotFoundException) { buf = new byte[0]; } if (old != null && old.snapshot.Equals(s) && Arrays.Equals(old.raw, buf)) { old.snapshot.SetClean(s); return old; } AList<LocalCachedPack> list = new AList<LocalCachedPack>(4); ICollection<ObjectId> tips = new HashSet<ObjectId>(); int ptr = 0; while (ptr < buf.Length) { if (buf[ptr] == '#' || buf[ptr] == '\n') { ptr = RawParseUtils.NextLF(buf, ptr); continue; } if (buf[ptr] == '+') { tips.AddItem(ObjectId.FromString(buf, ptr + 2)); ptr = RawParseUtils.NextLF(buf, ptr + 2); continue; } IList<string> names = new AList<string>(4); while (ptr < buf.Length && buf[ptr] == 'P') { int end = RawParseUtils.NextLF(buf, ptr); if (buf[end - 1] == '\n') { end--; } names.AddItem(RawParseUtils.Decode(buf, ptr + 2, end)); ptr = RawParseUtils.NextLF(buf, end); } if (!tips.IsEmpty() && !names.IsEmpty()) { list.AddItem(new LocalCachedPack(this, tips, names)); tips = new HashSet<ObjectId>(); } } list.TrimToSize(); return new ObjectDirectory.CachedPackList(s, Sharpen.Collections.UnmodifiableList (list), buf); }
/// <exception cref="System.IO.IOException"></exception> private void RecvWants() { HashSet<ObjectId> wantIds = new HashSet<ObjectId>(); bool isFirst = true; for (; ; ) { string line; try { line = pckIn.ReadString(); } catch (EOFException eof) { if (isFirst) { break; } throw; } if (line == PacketLineIn.END) { break; } if (!line.StartsWith("want ") || line.Length < 45) { throw new PackProtocolException(MessageFormat.Format(JGitText.Get().expectedGot, "want", line)); } if (isFirst && line.Length > 45) { string opt = Sharpen.Runtime.Substring(line, 45); if (opt.StartsWith(" ")) { opt = Sharpen.Runtime.Substring(opt, 1); } foreach (string c in opt.Split(" ")) { options.AddItem(c); } line = Sharpen.Runtime.Substring(line, 0, 45); } wantIds.AddItem(ObjectId.FromString(Sharpen.Runtime.Substring(line, 5))); isFirst = false; } if (wantIds.IsEmpty()) { return; } AsyncRevObjectQueue q = walk.ParseAny(wantIds.AsIterable (), true); try { for (; ; ) { RevObject o; try { o = q.Next(); } catch (IOException error) { throw new PackProtocolException(MessageFormat.Format(JGitText.Get().notValid, error .Message), error); } if (o == null) { break; } if (o.Has(WANT)) { } else { // Already processed, the client repeated itself. if (o.Has(ADVERTISED)) { o.Add(WANT); wantAll.AddItem(o); if (o is RevTag) { o = walk.Peel(o); if (o is RevCommit) { if (!o.Has(WANT)) { o.Add(WANT); wantAll.AddItem(o); } } } } else { throw new PackProtocolException(MessageFormat.Format(JGitText.Get().notValid, o.Name )); } } } } finally { q.Release(); } }