public static Animator CreateAnimator (this ImmutableList<IAnimationSection> animationSections, ImmutableList<IRenderer> children) { return new Animator(animationSections, children); }
private void ApplyOverrides(ImmutableList<FileModel> models, IHostService host) { foreach (var uid in host.GetAllUids()) { var ms = host.LookupByUid(uid); var od = ms.SingleOrDefault(m => m.Type == DocumentType.Override); if (od != null) { var ovm = ((List<ItemViewModel>)od.Content).Single(vm => vm.Uid == uid); foreach ( var pair in from model in ms where model.Type == DocumentType.Article from item in ((PageViewModel)model.Content).Items where item.Uid == uid select new { model, item }) { var vm = pair.item; // todo : fix file path Merger.Merge(ref vm, ovm); ((HashSet<string>)pair.model.Properties.LinkToUids).UnionWith((HashSet<string>)od.Properties.LinkToUids); ((HashSet<string>)pair.model.Properties.LinkToFiles).UnionWith((HashSet<string>)od.Properties.LinkToFiles); } } } }
public void EnumeratorLengthTest1() { var list1 = new ImmutableList<int>(new int[] { 0, 1, 2 }); var list2 = new ImmutableList<int>(new int[] { 3, 4, 5 }); var list = list1.Concat(list2); Assert.True(list.Length == 6); list = list.Tail(); Assert.True(list.Length == 5); list = list.Tail(); list = list.Tail(); list = list.Tail(); list = list.Tail(); Assert.True(list.Length == 1); Assert.True(list.IsAlmostEmpty); list = list.Tail(); Assert.True(list.IsEmpty); Assert.Throws<ParserException>(() => list.Tail()); }
public NavigationItem(string displayName, int imageIndex, [CanBeNull] Location location, int navigationPoint, ImmutableList<NavigationItem> children=null) { Extent = location?.Extent; NavigationPoint = navigationPoint; DisplayName = displayName; ImageIndex = imageIndex; Children = children?? ImmutableList<NavigationItem>.Empty; }
public CompanyState(Company company, int money, int loans, ImmutableList<Train> trains) { Company = company; Money = money; Loans = loans; Trains = trains; }
protected override void OnLoad(EventArgs e) { base.OnLoad (e); String version = GL.GetString(StringName.Version); Console.WriteLine("GL version: " + version); context = GLGraphics.NewContext(Context, true); program = context.NewProgramFromFiles("Render.vert", "Render.frag"); texture0 = context.NewTexture(TextureMinFilter.Nearest, TextureMagFilter.Nearest, TextureWrapMode.Clamp, TextureWrapMode.Clamp); texture0.UploadImage(sourceImage); sourceImage.Dispose(); texture1 = context.NewTexture(TextureMinFilter.Nearest, TextureMagFilter.Nearest, TextureWrapMode.Clamp, TextureWrapMode.Clamp); texture1.UploadImage(new byte[4 * 4 * 4], 4, 4, PixelInternalFormat.Four, PixelFormat.Rgba, PixelType.UnsignedByte); CreateAndFillBuffers(); paramSpec = ImmutableList<Tuple<String, Object>>.List(new Tuple<String, Object>[] { Tuple.Create<String, Object>("a_position", positions), Tuple.Create<String, Object>("a_texPos", textureCoords), Tuple.Create<String, Object>("u_texture0", texture0), Tuple.Create<String, Object>("u_texture1", texture1)}); }
public VisualStudioDocumentTrackingService(IServiceProvider serviceProvider) { _visibleFrames = ImmutableList<FrameListener>.Empty; _monitorSelection = (IVsMonitorSelection)serviceProvider.GetService(typeof(SVsShellMonitorSelection)); _monitorSelection.AdviseSelectionEvents(this, out _cookie); }
public static Order MakeMouseClick(ImmutableList<UInt16> selected, Vector point) { return new Order() { OrderType = 1, SelectedUnits = selected, PreparedOrderPoint = point }; }
public FakeHeaders(IEnumerable<ChainedHeader> blockHeaders) { this.blockHeaders = ImmutableList.CreateRange(blockHeaders).ToBuilder(); this.bits = DataCalculator.ToCompact(UnitTestParams.Target0); this.nonce = (UInt32)Interlocked.Increment(ref staticNonce); this.totalWork = blockHeaders.LastOrDefault()?.TotalWork ?? 0; }
public RoleName Role(string name) { if (_roles.Exists(r => r.Name == name)) throw new ArgumentException("non-unique role name " + name); var roleName = new RoleName(name); _roles = _roles.Add(roleName); return roleName; }
private LinearInterpolationSurface(double[] values, IPlotFunction[] functions, LinearInterpolationSurfaceProjection projection) { int n = values.Length; if (functions.Length != n) { throw new ArgumentException(); } List<Tuple<double, IPlotFunction>> pairs = new List<Tuple<double, IPlotFunction>>(); for (int i = 0; i < n; i++) { pairs.Add(Tuple.Create<double, IPlotFunction>(values[i], functions[i])); } pairs.Sort((p1, p2) => p1.Item1.CompareTo(p2.Item1)); for (int i = 0; i < n; i++) { values[i] = pairs[i].Item1; functions[i] = pairs[i].Item2; } Count = n; Values = new ImmutableList<double>(values); Functions = new ImmutableList<IPlotFunction>(functions); Projection = projection; }
private PrivateAuctionRound(ImmutableList<Player> players, ImmutableList<PrivateCompany> privates, Auction<PrivateCompany> auction, Player activePlayer, Player lastToAct, int seedMoney) : base(players, activePlayer, lastToAct) { Privates = privates; CurrentAuction = auction; SeedMoney = seedMoney; }
// --- Initialization --- /// <summary> /// Initializes a new compilation document from a list of text lines. /// This method does not scan the inserted text lines to produce tokens. /// You must explicitely call UpdateTokensLines() to start an initial scan of the document. /// </summary> public CompilationDocument(TextSourceInfo textSourceInfo, IEnumerable<ITextLine> initialTextLines, TypeCobolOptions compilerOptions, IProcessedTokensDocumentProvider processedTokensDocumentProvider) { TextSourceInfo = textSourceInfo; CompilerOptions = compilerOptions; this.processedTokensDocumentProvider = processedTokensDocumentProvider; // Initialize the compilation document lines compilationDocumentLines = ImmutableList<CodeElementsLine>.Empty.ToBuilder(); // ... with the initial list of text lines received as a parameter if (initialTextLines != null) { // Insert Cobol text lines in the internal tree structure compilationDocumentLines.AddRange(initialTextLines.Select(textLine => CreateNewDocumentLine(textLine, textSourceInfo.ColumnsLayout))); } // Initialize document views versions currentTextLinesVersion = new DocumentVersion<ICobolTextLine>(this); currentTokensLinesVersion = new DocumentVersion<ITokensLine>(this); // Initialize performance stats PerfStatsForText = new PerfStatsForCompilationStep(CompilationStep.Text); PerfStatsForScanner = new PerfStatsForCompilationStep(CompilationStep.Scanner); PerfStatsForPreprocessor = new PerfStatsForCompilationStep(CompilationStep.Preprocessor); }
public MainForm() { InitializeComponent(); cmv = new CMV(); rawframes = new List<CMVFrame>(); cmvframes = new ImmutableList<CMVFrame>(rawframes, "empty"); copybuffer = new List<CMVFrame>(); foregroundColourPicker.Colors = CMVColours.ForegroundColors; backgroundColourPicker.Colors = CMVColours.BackgroundColors; updateDelayTimer = new Timer(); updateDelayTimer.Interval = 24; updateDelayTimer.Tick += handleUpdateDelayTimer; aboutBox = new AboutBox(); aboutBox.HelpButtonClicked += new EventHandler(action_HelpTopics); newFileDialog = new ChooseDimensionsBox(); loadTileset(); RefreshControls(); }
public BenchmarkDiff(BenchmarkRun left, BenchmarkRun right, ImmutableList<SourceLogEntry> log) { Left = left; Right = right; var leftResults = left.AllResults.ToList(); var rightResults = right.AllResults.ToList(); LeftOnly = leftResults.ExceptBy(rightResults, result => result.FullMethod); RightOnly = rightResults.ExceptBy(leftResults, result => result.FullMethod); var pairs = (from l in leftResults join r in rightResults on l.FullMethod equals r.FullMethod select new BenchmarkPair(l, r)).ToList(); LeftBetter = pairs.Where(pair => pair.Percent < ImprovementThreshold).ToList(); RightBetter = pairs.Where(pair => pair.Percent > RegressionThreshold).ToList(); bool leftEarlier = BenchmarkRepository.BuildForLabel(left.Label) < BenchmarkRepository.BuildForLabel(right.Label); var earlier = leftEarlier ? left : right; var later = leftEarlier ? right : left; var earlierHash = BenchmarkRepository.HashForLabel(earlier.Label); var laterHash = BenchmarkRepository.HashForLabel(later.Label); LogEntries = log.EntriesBetween(earlierHash, laterHash).ToList(); }
private static bool RecoursiveCheckGraph(Task root, ImmutableList<Guid> previousTasks) { Contract.Requires(root != null); Contract.Requires(root.Inputs != null); Contract.Requires(previousTasks != null); if (previousTasks.Contains(root.Id)) { Logger.Write( LogCategories.Error(string.Format( "{0} is cycled.", root), LogCategories.TaskServices)); return false; } foreach (var task in root.Inputs) { if (previousTasks.Contains(task.Id)) { Logger.Write( LogCategories.Error(string.Format( "{0} is cycled.", task), LogCategories.TaskServices)); return false; } if (!RecoursiveCheckGraph(task, previousTasks.Add(root.Id))) return false; } return true; }
public override ImmutableList<char> FreeVariableNames(ImmutableList<Symbol> boundVariables) { if (boundVariables.Contains(_variable)) return ImmutableList<char>.Empty; else return new char[] { _variable.Default }.ToImmutableList(); }
internal PathSpec(PathFlags flags, string directorySeparator, IEnumerable<string> elements) { ValidateFlags(flags); Flags = flags; DirectorySeparator = directorySeparator; Components = elements.SelectMany(SplitComponent).ToImmutableList(); }
public FakeHeaders() { this.blockHeaders = ImmutableList.CreateBuilder<ChainedHeader>(); this.bits = DataCalculator.TargetToBits(UnitTestRules.Target0); this.nonce = (UInt32)Interlocked.Increment(ref staticNonce); this.totalWork = 0; }
public static void Main() { var list = new List<ClassWithStringProperty>() { "test1", "test2", "test3", "test4"}; var imlist = new ImmutableList<ClassWithStringProperty>(list); Console.WriteLine("Lists created:"); Console.WriteLine(list.Stringify(e =>e.Prop)); Console.WriteLine(imlist.Stringify(e => e.Prop)); Console.WriteLine("Mutable list modified[immutable not modified]:"); list.Add("test5"); Console.WriteLine(list.Stringify(e => e.Prop)); Console.WriteLine(imlist.Stringify(e => e.Prop)); Console.WriteLine("Element in immutable changed[not really...]:"); var elem = imlist[2]; elem.Prop = "1234"; Console.WriteLine(imlist.Stringify(e => e.Prop)); Console.WriteLine("Element in mutable changed[& not in immutable]:"); elem = list[2]; elem.Prop = "12387"; Console.WriteLine(list.Stringify(e => e.Prop)); Console.WriteLine(imlist.Stringify(e => e.Prop)); Console.ReadLine(); }
public PathSyntaxReference(SyntaxNode node) { this.tree = node.SyntaxTree; this.kind = node.CSharpKind(); this.textSpan = node.Span; this.pathFromRoot = ComputePathFromRoot(node); }
/// <summary> /// 1. Expand the TOC reference /// 2. Resolve homepage /// </summary> /// <param name="models"></param> /// <param name="host"></param> /// <returns></returns> public override IEnumerable<FileModel> Prebuild(ImmutableList<FileModel> models, IHostService host) { var tocModelCache = new Dictionary<string, TocItemInfo>(); foreach (var model in models) { if (!tocModelCache.ContainsKey(model.OriginalFileAndType.FullPath)) { tocModelCache[model.OriginalFileAndType.FullPath] = new TocItemInfo(model.OriginalFileAndType, (TocItemViewModel)model.Content); } } var tocResolver = new TocResolver(host, tocModelCache); foreach (var key in tocModelCache.Keys.ToList()) { tocModelCache[key] = tocResolver.Resolve(key); } foreach (var model in models) { var wrapper = tocModelCache[model.OriginalFileAndType.FullPath]; // If the TOC file is referenced by other TOC, remove it from the collection if (!wrapper.IsReferenceToc) { model.Content = wrapper.Content; yield return model; } } }
public void JoinSeedNodeSpecs() { _seedNodes = ImmutableList.Create(GetAddress(_config.Seed1), GetAddress(_config.Seed2), GetAddress(_config.Seed3)); AClusterWithSeedNodesMustBeAbleToStartTheSeedNodesConcurrently(); AClusterWithSeedNodesMustBeAbleToJoinTheSeedNodes(); }
internal ProjectDependencyGraph( ImmutableList<ProjectId> projectIds, ImmutableDictionary<ProjectId, ImmutableHashSet<ProjectId>> referencesMap) { this.projectIds = projectIds; this.referencesMap = referencesMap; }
public void JoinSeedNodeSpecs() { _seedNodes = ImmutableList.Create(GetAddress(_config.Seed1), GetAddress(_config.Seed2), GetAddress(_config.Seed3)); A_cluster_with_seed_nodes_must_be_able_to_start_the_seed_nodes_concurrently(); A_cluster_with_seed_nodes_must_be_able_to_join_the_seed_nodes(); }
private Solution( BranchId branchId, int workspaceVersion, SolutionServices solutionServices, SolutionId id, string filePath, ImmutableList<ProjectId> projectIds, ImmutableDictionary<ProjectId, ProjectState> idToProjectStateMap, ImmutableDictionary<ProjectId, CompilationTracker> projectIdToTrackerMap, ProjectDependencyGraph dependencyGraph, VersionStamp version, Lazy<VersionStamp> lazyLatestProjectVersion) { this.branchId = branchId; this.workspaceVersion = workspaceVersion; this.id = id; this.filePath = filePath; this.solutionServices = solutionServices; this.projectIds = projectIds; this.projectIdToProjectStateMap = idToProjectStateMap; this.projectIdToTrackerMap = projectIdToTrackerMap; this.dependencyGraph = dependencyGraph; this.projectIdToProjectMap = ImmutableHashMap<ProjectId, Project>.Empty; this.version = version; this.lazyLatestProjectVersion = lazyLatestProjectVersion; CheckInvariants(); }
public FakeHeaders(IEnumerable<ChainedHeader> blockHeaders) { this.blockHeaders = ImmutableList.CreateRange(blockHeaders).ToBuilder(); this.bits = DataCalculator.TargetToBits(UnitTestRules.Target0); this.nonce = (UInt32)Interlocked.Increment(ref staticNonce); this.totalWork = this.blockHeaders.Sum(x => x.BlockHeader.CalculateWork()); }
public SyntaxTree(ChunkNode root, List<Token> tokens, List<StatementNode> statementNodeList, ImmutableList<ParseError> errorList) { this.Root = root; this.Tokens = tokens; this.ErrorList = errorList; this.StatementNodeList = statementNodeList; }
public FSharpCompilationException(IEnumerable<FSharpDiagnosticMessage> diagnostics) : base(GetErrorMessage(diagnostics)) { _failures = diagnostics.Where(d => d.Severity == DiagnosticMessageSeverity.Error) .GroupBy(d => d.SourceFilePath, StringComparer.OrdinalIgnoreCase) .Select(g => new FSharpCompilationFailure(g.Key, g)) .ToImmutableList(); }
public void SetInstructions(ImmutableList<string> instructions) { _instructions.Clear(); _instructions.AddRange(instructions); _playhead.Value = 0; Save(); }
public FFmpegFilterChainItem(ImmutableList <FFmpegPad> inputStreams, FFmpegFilter filter) : this(inputStreams, filter, ImmutableList.Create <FFmpegPad>()) { }
public FFmpegFilterChainItem(FFmpegFilter filter, ImmutableList <FFmpegPad> outputStreams) : this(ImmutableList.Create <FFmpegPad>(), filter, outputStreams) { }
public FFmpegFilterChainItem(FFmpegFilter filter) : this(ImmutableList.Create <FFmpegPad>(), filter, ImmutableList.Create <FFmpegPad>()) { }
public static IMyObjectPrx Run(TestHelper helper) { bool ice2 = helper.Protocol == Protocol.Ice2; var prx = IMyObjectPrx.Parse(helper.GetTestProxy("test"), helper.Communicator !); System.IO.TextWriter output = helper.Output; output.Write("testing retry... "); output.Flush(); TestHelper.Assert(prx.AddWithRetry(33, 12) == 45); output.WriteLine("ok"); output.Write("testing remote exception... "); output.Flush(); try { prx.BadAdd(33, 12); TestHelper.Assert(false); } catch (InvalidInputException) { // expected } output.WriteLine("ok"); output.Write("testing ONE... "); output.Flush(); try { prx.NotExistAdd(33, 12); TestHelper.Assert(false); } catch (ObjectNotExistException) { // expected } output.WriteLine("ok"); output.Write("testing exceptions raised by the interceptor... "); output.Flush(); var exceptions = new List <(string operation, string kind)> { ("raiseBeforeDispatch", "invalidInput"), ("raiseBeforeDispatch", "notExist"), ("raiseAfterDispatch", "invalidInput"), ("raiseAfterDispatch", "notExist") }; foreach ((string operation, string kind) in exceptions) { var ctx = new Dictionary <string, string> { { operation, kind } }; try { prx.IcePing(ctx); TestHelper.Assert(false); } catch (InvalidInputException) when(kind == "invalidInput") { } catch (ObjectNotExistException) when(kind == "notExist") { } } output.WriteLine("ok"); output.Write("testing invocation interceptors... "); output.Flush(); { var tasks = new List <Task>(); var invocationContext = new AsyncLocal <int>(); using var communicator = new Communicator(prx.Communicator.GetProperties()); communicator.DefaultInvocationInterceptors = ImmutableList.Create <InvocationInterceptor>( (target, request, next, cancel) => { request.WritableContext["interceptor-1"] = "interceptor-1"; if (ice2) { request.BinaryContextOverride.Add(110, ostr => ostr.WriteInt(110)); } return(next(target, request, cancel)); }, async(target, request, next, cancel) => { TestHelper.Assert(request.Context["interceptor-1"] == "interceptor-1"); request.WritableContext["interceptor-2"] = "interceptor-2"; if (ice2) { request.BinaryContextOverride.Add(120, ostr => ostr.WriteInt(120)); } IncomingResponseFrame response = await next(target, request, cancel); TestHelper.Assert(invocationContext.Value == int.Parse(request.Context["local-user"])); if (ice2) { TestHelper.Assert(response.BinaryContext.ContainsKey(110)); TestHelper.Assert(response.BinaryContext[110].Read(istr => istr.ReadInt()) == 110); TestHelper.Assert(response.BinaryContext.ContainsKey(120)); TestHelper.Assert(response.BinaryContext[120].Read(istr => istr.ReadInt()) == 120); } return(response); }); communicator.ActivateAsync().GetAwaiter().GetResult(); for (int i = 0; i < 10; ++i) { invocationContext.Value = i; var prx1 = IMyObjectPrx.Parse(prx.ToString() !, communicator); Task t = prx1.Op1Async(new Dictionary <string, string> { { "local-user", $"{i}" } }); tasks.Add(t); } Task.WaitAll(tasks.ToArray()); } { IncomingResponseFrame?response = null; int invocations = 0; // An interceptor can stop the chain and directly return a response without calling next, // the first invocation calls next and subsequent invocations reuse the first response. using var communicator = new Communicator(prx.Communicator.GetProperties()); communicator.DefaultInvocationInterceptors = ImmutableList.Create <InvocationInterceptor>( (target, request, next, cancel) => { request.WritableContext["interceptor-1"] = "interceptor-1"; return(next(target, request, cancel)); }, async(target, request, next, cancel) => { if (response == null) { response = await next(target, request, cancel); } return(response); }, (target, request, next, cancel) => { invocations++; TestHelper.Assert(response == null); return(next(target, request, cancel)); }); TestHelper.Assert(communicator.DefaultInvocationInterceptors.Count == 3); communicator.ActivateAsync().GetAwaiter().GetResult(); TestHelper.Assert(communicator.DefaultInvocationInterceptors.Count == 4); var prx1 = IMyObjectPrx.Parse(prx.ToString() !, communicator); // Truly reference equal TestHelper.Assert(prx1.InvocationInterceptors == communicator.DefaultInvocationInterceptors); prx1.Op1(new Dictionary <string, string> { { "local-user", "10" } }); prx1.Op1(new Dictionary <string, string> { { "local-user", "11" } }); prx1.Op1(new Dictionary <string, string> { { "local-user", "12" } }); TestHelper.Assert(invocations == 1); } { // throwing from an interceptor stops the interceptor chain using var communicator = new Communicator(prx.Communicator.GetProperties()); communicator.DefaultInvocationInterceptors = ImmutableList.Create <InvocationInterceptor>( (target, request, next, cancel) => { request.WritableContext["interceptor-1"] = "interceptor-1"; return(next(target, request, cancel)); }, (target, request, next, cancel) => { TestHelper.Assert(request.Context["interceptor-1"] == "interceptor-1"); throw new InvalidOperationException("stop interceptor chain"); }, (target, request, next, cancel) => { TestHelper.Assert(false); return(next(target, request, cancel)); }); communicator.ActivateAsync().GetAwaiter().GetResult(); var prx1 = IMyObjectPrx.Parse(prx.ToString() !, communicator); try { prx1.Op1(); TestHelper.Assert(false); } catch (InvalidOperationException) { } } output.WriteLine("ok"); output.Write("testing binary context... "); output.Flush(); if (ice2) { for (int size = 128; size < 4096; size *= 2) { var token = new Token(1, "mytoken", Enumerable.Range(0, size).Select(i => (byte)2).ToArray()); { using var request = OutgoingRequestFrame.WithArgs(prx, "opWithBinaryContext", idempotent: false, compress: false, format: default, context: null, token, Token.IceWriter); request.BinaryContextOverride.Add(1, ostr => ostr.WriteStruct(token)); request.BinaryContextOverride.Add(3, ostr => ostr.WriteShort((short)size)); request.BinaryContextOverride.Add( 2, ostr => ostr.WriteSequence( Enumerable.Range(0, 10).Select(i => $"string-{i}").ToArray(), (ostr, s) => ostr.WriteString(s))); using IncomingResponseFrame response = prx.InvokeAsync(request).Result; } { // repeat with compressed frame using OutgoingRequestFrame request = OutgoingRequestFrame.WithArgs(prx, "opWithBinaryContext", idempotent: false, compress: false, format: default, context: null, token, Token.IceWriter); request.BinaryContextOverride.Add(1, ostr => ostr.WriteStruct(token)); request.BinaryContextOverride.Add(3, ostr => ostr.WriteShort((short)size)); request.BinaryContextOverride.Add( 2, ostr => ostr.WriteSequence( Enumerable.Range(0, 10).Select(i => $"string-{i}").ToArray(), (ostr, s) => ostr.WriteString(s))); TestHelper.Assert(request.CompressPayload() == CompressionResult.Success); using IncomingResponseFrame response = prx.InvokeAsync(request).Result; } { // repeat compressed the frame before writing the context using OutgoingRequestFrame request = OutgoingRequestFrame.WithArgs(prx, "opWithBinaryContext", idempotent: false, compress: false, format: default, context: null, token, Token.IceWriter); TestHelper.Assert(request.CompressPayload() == CompressionResult.Success); request.BinaryContextOverride.Add(1, ostr => ostr.WriteStruct(token)); request.BinaryContextOverride.Add(3, ostr => ostr.WriteShort((short)size)); request.BinaryContextOverride.Add( 2, ostr => ostr.WriteSequence( Enumerable.Range(0, 10).Select(i => $"string-{i}").ToArray(), (ostr, s) => ostr.WriteString(s))); using IncomingResponseFrame response = prx.InvokeAsync(request).Result; } } } else { var token = new Token(1, "mytoken", Enumerable.Range(0, 256).Select(i => (byte)2).ToArray()); using var request = OutgoingRequestFrame.WithArgs(prx, "opWithBinaryContext", idempotent: false, compress: false, format: default, context: null, token, Token.IceWriter); try { request.BinaryContextOverride.Add(1, ostr => ostr.WriteStruct(token)); TestHelper.Assert(false); } catch (NotSupportedException) { } using IncomingResponseFrame response = prx.InvokeAsync(request).Result; } output.WriteLine("ok"); output.Write("testing per proxy invocation interceptors... "); output.Flush(); { var communicator = helper.Communicator !; SortedDictionary <string, string>?context = prx.Op2(); TestHelper.Assert(context["context1"] == "plug-in"); TestHelper.Assert(context["context2"] == "plug-in"); TestHelper.Assert(!context.ContainsKey("context3")); prx = prx.Clone(invocationInterceptors: ImmutableList.Create <InvocationInterceptor>( (target, request, next, cancel) => { request.WritableContext["context2"] = "proxy"; request.WritableContext["context3"] = "proxy"; return(next(target, request, cancel)); }).AddRange(communicator.DefaultInvocationInterceptors)); context = prx.Op2(); TestHelper.Assert(context["context1"] == "plug-in"); TestHelper.Assert(context["context2"] == "plug-in"); TestHelper.Assert(context["context3"] == "proxy"); // Calling next twice doesn't change the result prx = prx.Clone(invocationInterceptors: ImmutableList.Create <InvocationInterceptor>( (target, request, next, cancel) => { request.WritableContext["context2"] = "proxy"; request.WritableContext["context3"] = "proxy"; _ = next(target, request, cancel); return(next(target, request, cancel)); }).AddRange(communicator.DefaultInvocationInterceptors)); context = prx.Op2(); TestHelper.Assert(context["context1"] == "plug-in"); TestHelper.Assert(context["context2"] == "plug-in"); TestHelper.Assert(context["context3"] == "proxy"); // Cloning the proxy preserve its interceptors prx = prx.Clone(invocationTimeout: TimeSpan.FromSeconds(10)); context = prx.Op2(); TestHelper.Assert(context["context1"] == "plug-in"); TestHelper.Assert(context["context2"] == "plug-in"); TestHelper.Assert(context["context3"] == "proxy"); // The server increments the result with each call when using the invocation interceptor we // return a cached response, and we will see the same result with each call. IncomingResponseFrame?response = null; prx = prx.Clone(invocationInterceptors: ImmutableList.Create <InvocationInterceptor>( async(target, request, next, cancel) => { response ??= await next(target, request, cancel); return(response); }).AddRange(communicator.DefaultInvocationInterceptors)); TestHelper.Assert(prx.Op3() == 0); TestHelper.Assert(prx.Op3() == 0); // After clearing the invocation interceptors we should see the result increase with each call prx = prx.Clone(invocationInterceptors: communicator.DefaultInvocationInterceptors); TestHelper.Assert(prx.Op3() == 1); TestHelper.Assert(prx.Op3() == 2); } output.WriteLine("ok"); return(prx); }
public void RemoveRangeEnumerableTest() { var list = ImmutableList.Create(1, 2, 3); AssertExtensions.Throws <ArgumentNullException>("items", () => list.RemoveRange(null)); ImmutableList <int> removed2 = list.RemoveRange(new[] { 2 }); Assert.Equal(2, removed2.Count); Assert.Equal(new[] { 1, 3 }, removed2); ImmutableList <int> removed13 = list.RemoveRange(new[] { 1, 3, 5 }); Assert.Equal(1, removed13.Count); Assert.Equal(new[] { 2 }, removed13); Assert.Equal(new[] { 2 }, ((IImmutableList <int>)list).RemoveRange(new[] { 1, 3, 5 })); Assert.Same(list, list.RemoveRange(new[] { 5 })); Assert.Same(ImmutableList.Create <int>(), ImmutableList.Create <int>().RemoveRange(new[] { 1 })); var listWithDuplicates = ImmutableList.Create(1, 2, 2, 3); Assert.Equal(new[] { 1, 2, 3 }, listWithDuplicates.RemoveRange(new[] { 2 })); Assert.Equal(new[] { 1, 3 }, listWithDuplicates.RemoveRange(new[] { 2, 2 })); AssertExtensions.Throws <ArgumentNullException>("items", () => ((IImmutableList <int>)ImmutableList.Create(1, 2, 3)).RemoveRange(null)); Assert.Equal(new[] { 1, 3 }, ((IImmutableList <int>)ImmutableList.Create(1, 2, 3)).RemoveRange(new[] { 2 })); }
static void LogWorkspaceDiagnostics(ILogger logger, bool logWorkspaceWarnings, ImmutableList <WorkspaceDiagnostic> diagnostics) { if (!logWorkspaceWarnings) { if (diagnostics.Count > 0) { logger.LogWarning(Resources.Warnings_were_encountered_while_loading_the_workspace_Set_the_verbosity_option_to_the_diagnostic_level_to_log_warnings); } return; } foreach (var diagnostic in diagnostics) { if (diagnostic.Kind == WorkspaceDiagnosticKind.Failure) { logger.LogError(diagnostic.Message); } else { logger.LogWarning(diagnostic.Message); } } }
public bool Equals(Temp other) { if (other == null) { throw new Exception("Equals failed."); } if (ReferenceEquals(this, other)) { throw new Exception("Equals failed."); } if (IntIntArray.Rank != other.IntIntArray.Rank) { throw new Exception("Equals failed."); } for (var i = 0; i < IntIntArray.Rank; ++i) { for (var j = 0; j < IntIntArray.GetLength(i); ++j) { if (IntIntArray[j, i] != other.IntIntArray[j, i]) { throw new Exception("Equals failed."); } } } if (Exception.GetType() != other.Exception.GetType()) { throw new Exception("Equals failed."); } if (Exception.Message != other.Exception.Message) { throw new Exception("Equals failed."); } if (Exception.InnerException != null && Exception.InnerException.GetType() != other.Exception.InnerException.GetType()) { throw new Exception("Equals failed."); } for (var i = 0; i < SubArray.Length; i++) { if (SubArray[i].GetType() != other.SubArray[i].GetType()) { throw new Exception("Equals failed."); } if (SubArray[i] is Array arr) { var oArr = (Array)other.SubArray[i]; for (var j = 0; j < arr.Length; ++j) { if (!arr.GetValue(j).Equals(oArr.GetValue(j))) { throw new Exception("Equals failed."); } } } else if (!SubArray[i].Equals(other.SubArray[i])) { throw new Exception("Equals failed."); } } foreach (var key in Dictionary.Keys) { if (!Dictionary[key].Equals(other.Dictionary[key])) { throw new Exception("Equals failed."); } } foreach (var key in ImmutableDictionary.Keys) { if (!ImmutableDictionary[key].Equals(other.ImmutableDictionary[key])) { throw new Exception("Equals failed."); } } if (other.Delegate(2, 2) != 4) { throw new Exception("Equals failed."); } if (!IntArray.SequenceEqual(other.IntArray)) { throw new Exception("Equals failed."); } if (!Equals(Poco, other.Poco)) { throw new Exception("Equals failed."); } if (String != other.String) { throw new Exception("Equals failed."); } if (!TestEnum.SequenceEqual(other.TestEnum)) { throw new Exception("Equals failed."); } if (!ImmutableList.SequenceEqual(other.ImmutableList)) { throw new Exception("Equals failed."); } return(true); }
private readonly ImmutableSet <Index> indices; // not a property, derived and cached from input data //------------------------------------------------------------------------- /// <summary> /// Creates a swap from one or more swap legs. /// <para> /// While most swaps have two legs, other combinations are possible. /// /// </para> /// </summary> /// <param name="legs"> the array of legs </param> /// <returns> the swap </returns> public static ResolvedSwap of(params ResolvedSwapLeg[] legs) { ArgChecker.notEmpty(legs, "legs"); return(new ResolvedSwap(ImmutableList.copyOf(legs))); }
public SslServerCredentials(ImmutableList <KeyCertificatePair> keyCertPairs) { this.keyCertPairs = keyCertPairs; }
/// <summary> /// Sets the {@code legs} property in the builder /// from an array of objects. </summary> /// <param name="legs"> the new value, not empty </param> /// <returns> this, for chaining, not null </returns> public Builder legs(params ResolvedSwapLeg[] legs) { return(this.legs(ImmutableList.copyOf(legs))); }
public void ArrayAsRootObject() { const string ExpectedJson = @"[1,true,{""City"":""MyCity""},null,""foo""]"; const string ReversedExpectedJson = @"[""foo"",null,{""City"":""MyCity""},true,1]"; string[] expectedObjects = { @"""foo""", @"null", @"{""City"":""MyCity""}", @"true", @"1" }; var address = new Address(); address.Initialize(); var array = new object[] { 1, true, address, null, "foo" }; string json = Serializer.Serialize(array); Assert.Equal(ExpectedJson, json); var dictionary = new Dictionary <string, string> { { "City", "MyCity" } }; var arrayWithDictionary = new object[] { 1, true, dictionary, null, "foo" }; json = Serializer.Serialize(arrayWithDictionary); Assert.Equal(ExpectedJson, json); json = Serializer.Serialize <object>(array); Assert.Equal(ExpectedJson, json); List <object> list = new List <object> { 1, true, address, null, "foo" }; json = Serializer.Serialize(list); Assert.Equal(ExpectedJson, json); json = Serializer.Serialize <object>(list); Assert.Equal(ExpectedJson, json); IEnumerable ienumerable = new List <object> { 1, true, address, null, "foo" }; json = Serializer.Serialize(ienumerable); Assert.Equal(ExpectedJson, json); json = Serializer.Serialize <object>(ienumerable); Assert.Equal(ExpectedJson, json); IList ilist = new List <object> { 1, true, address, null, "foo" }; json = Serializer.Serialize(ilist); Assert.Equal(ExpectedJson, json); json = Serializer.Serialize <object>(ilist); Assert.Equal(ExpectedJson, json); ICollection icollection = new List <object> { 1, true, address, null, "foo" }; json = Serializer.Serialize(icollection); Assert.Equal(ExpectedJson, json); json = Serializer.Serialize <object>(icollection); Assert.Equal(ExpectedJson, json); IEnumerable <object> genericIEnumerable = new List <object> { 1, true, address, null, "foo" }; json = Serializer.Serialize(genericIEnumerable); Assert.Equal(ExpectedJson, json); json = Serializer.Serialize <object>(genericIEnumerable); Assert.Equal(ExpectedJson, json); IList <object> genericIList = new List <object> { 1, true, address, null, "foo" }; json = Serializer.Serialize(genericIList); Assert.Equal(ExpectedJson, json); json = Serializer.Serialize <object>(genericIList); Assert.Equal(ExpectedJson, json); ICollection <object> genericICollection = new List <object> { 1, true, address, null, "foo" }; json = Serializer.Serialize(genericICollection); Assert.Equal(ExpectedJson, json); json = Serializer.Serialize <object>(genericICollection); Assert.Equal(ExpectedJson, json); IReadOnlyCollection <object> genericIReadOnlyCollection = new List <object> { 1, true, address, null, "foo" }; json = Serializer.Serialize(genericIReadOnlyCollection); Assert.Equal(ExpectedJson, json); json = Serializer.Serialize <object>(genericIReadOnlyCollection); Assert.Equal(ExpectedJson, json); IReadOnlyList <object> genericIReadonlyList = new List <object> { 1, true, address, null, "foo" }; json = Serializer.Serialize(genericIReadonlyList); Assert.Equal(ExpectedJson, json); json = Serializer.Serialize <object>(genericIReadonlyList); Assert.Equal(ExpectedJson, json); ISet <object> iset = new HashSet <object> { 1, true, address, null, "foo" }; json = Serializer.Serialize(iset); Assert.Equal(ExpectedJson, json); json = Serializer.Serialize <object>(iset); Assert.Equal(ExpectedJson, json); Stack <object> stack = new Stack <object>(new List <object> { 1, true, address, null, "foo" }); json = Serializer.Serialize(stack); Assert.Equal(ReversedExpectedJson, json); json = Serializer.Serialize <object>(stack); Assert.Equal(ReversedExpectedJson, json); Queue <object> queue = new Queue <object>(new List <object> { 1, true, address, null, "foo" }); json = Serializer.Serialize(queue); Assert.Equal(ExpectedJson, json); json = Serializer.Serialize <object>(queue); Assert.Equal(ExpectedJson, json); HashSet <object> hashset = new HashSet <object>(new List <object> { 1, true, address, null, "foo" }); json = Serializer.Serialize(hashset); Assert.Equal(ExpectedJson, json); json = Serializer.Serialize <object>(hashset); Assert.Equal(ExpectedJson, json); LinkedList <object> linkedlist = new LinkedList <object>(new List <object> { 1, true, address, null, "foo" }); json = Serializer.Serialize(linkedlist); Assert.Equal(ExpectedJson, json); json = Serializer.Serialize <object>(linkedlist); Assert.Equal(ExpectedJson, json); ImmutableArray <object> immutablearray = ImmutableArray.CreateRange(new List <object> { 1, true, address, null, "foo" }); json = Serializer.Serialize(immutablearray); Assert.Equal(ExpectedJson, json); json = Serializer.Serialize <object>(immutablearray); Assert.Equal(ExpectedJson, json); IImmutableList <object> iimmutablelist = ImmutableList.CreateRange(new List <object> { 1, true, address, null, "foo" }); json = Serializer.Serialize(iimmutablelist); Assert.Equal(ExpectedJson, json); json = Serializer.Serialize <object>(iimmutablelist); Assert.Equal(ExpectedJson, json); IImmutableStack <object> iimmutablestack = ImmutableStack.CreateRange(new List <object> { 1, true, address, null, "foo" }); json = Serializer.Serialize(iimmutablestack); Assert.Equal(ReversedExpectedJson, json); json = Serializer.Serialize <object>(iimmutablestack); Assert.Equal(ReversedExpectedJson, json); IImmutableQueue <object> iimmutablequeue = ImmutableQueue.CreateRange(new List <object> { 1, true, address, null, "foo" }); json = Serializer.Serialize(iimmutablequeue); Assert.Equal(ExpectedJson, json); json = Serializer.Serialize <object>(iimmutablequeue); Assert.Equal(ExpectedJson, json); IImmutableSet <object> iimmutableset = ImmutableHashSet.CreateRange(new List <object> { 1, true, address, null, "foo" }); json = Serializer.Serialize(iimmutableset); foreach (string obj in expectedObjects) { Assert.Contains(obj, json); } json = Serializer.Serialize <object>(iimmutableset); foreach (string obj in expectedObjects) { Assert.Contains(obj, json); } ImmutableHashSet <object> immutablehashset = ImmutableHashSet.CreateRange(new List <object> { 1, true, address, null, "foo" }); json = Serializer.Serialize(immutablehashset); foreach (string obj in expectedObjects) { Assert.Contains(obj, json); } json = Serializer.Serialize <object>(immutablehashset); foreach (string obj in expectedObjects) { Assert.Contains(obj, json); } ImmutableList <object> immutablelist = ImmutableList.CreateRange(new List <object> { 1, true, address, null, "foo" }); json = Serializer.Serialize(immutablelist); Assert.Equal(ExpectedJson, json); json = Serializer.Serialize <object>(immutablelist); Assert.Equal(ExpectedJson, json); ImmutableStack <object> immutablestack = ImmutableStack.CreateRange(new List <object> { 1, true, address, null, "foo" }); json = Serializer.Serialize(immutablestack); Assert.Equal(ReversedExpectedJson, json); json = Serializer.Serialize <object>(immutablestack); Assert.Equal(ReversedExpectedJson, json); ImmutableQueue <object> immutablequeue = ImmutableQueue.CreateRange(new List <object> { 1, true, address, null, "foo" }); json = Serializer.Serialize(immutablequeue); Assert.Equal(ExpectedJson, json); json = Serializer.Serialize <object>(immutablequeue); Assert.Equal(ExpectedJson, json); }
public void ToImmutableListOfSameType() { var list = ImmutableList.Create("a"); Assert.Same(list, list.ToImmutableList()); }
public FFmpegFilterChainItem(ImmutableList <FFmpegPad> inputStreams, FFmpegFilter filter, ImmutableList <FFmpegPad> outputStreams) { ErrorUtils.ThrowIfArgNull(inputStreams, nameof(inputStreams)); ErrorUtils.ThrowIfArgNull(filter, nameof(filter)); ErrorUtils.ThrowIfArgNull(outputStreams, nameof(outputStreams)); this.InputStreams = inputStreams; this.Filter = filter; this.OutputStreams = outputStreams; }
public void Dispose() { _entries = ImmutableList <UIBuildSummary> .Empty; }
/// <summary> /// Initializes a new instance of the <see cref="ZenAdapterExpr{TTo, TFrom}"/> class. /// </summary> /// <param name="expr">The expression.</param> /// <param name="converters">Converter between types.</param> private ZenAdapterExpr(Zen <TFrom> expr, ImmutableList <Func <object, object> > converters) { this.Expr = expr; this.Converters = converters; }
public MarkdownRewriterContext(ICompositionContainer container, ImmutableList <MarkdownTagValidationRule> validators) { Container = container; Validators = validators; }
public ViewLibraryPepInfoList(IEnumerable <ViewLibraryPepInfo> items) { _allEntries = ImmutableList.ValueOf(items.OrderBy(item => item, Comparer <ViewLibraryPepInfo> .Create(ComparePepInfos))); }
public virtual void test_pv01_calibrated() { FixedCouponBondTradeCalculationFunction <FixedCouponBondTrade> function = FixedCouponBondTradeCalculationFunction.TRADE; ScenarioMarketData md = marketData(); LegalEntityDiscountingProvider provider = LOOKUP.marketDataView(md.scenario(0)).discountingProvider(); DiscountingFixedCouponBondTradePricer pricer = DiscountingFixedCouponBondTradePricer.DEFAULT; PointSensitivities pvPointSens = pricer.presentValueSensitivity(RTRADE, provider); CurrencyParameterSensitivities pvParamSens = provider.parameterSensitivity(pvPointSens); MultiCurrencyAmount expectedPv01Cal = pvParamSens.total().multipliedBy(1e-4); CurrencyParameterSensitivities expectedPv01CalBucketed = pvParamSens.multipliedBy(1e-4); ISet <Measure> measures = ImmutableSet.of(Measures.PV01_CALIBRATED_SUM, Measures.PV01_CALIBRATED_BUCKETED); assertThat(function.calculate(TRADE, measures, PARAMS, md, REF_DATA)).containsEntry(Measures.PV01_CALIBRATED_SUM, Result.success(MultiCurrencyScenarioArray.of(ImmutableList.of(expectedPv01Cal)))).containsEntry(Measures.PV01_CALIBRATED_BUCKETED, Result.success(ScenarioArray.of(ImmutableList.of(expectedPv01CalBucketed)))); }
public void IsSynchronized() { ICollection collection = ImmutableList.Create <int>(); Assert.True(collection.IsSynchronized); }
public virtual void test_simpleMeasures() { FixedCouponBondTradeCalculationFunction <FixedCouponBondTrade> function = FixedCouponBondTradeCalculationFunction.TRADE; ScenarioMarketData md = marketData(); LegalEntityDiscountingProvider provider = LOOKUP.marketDataView(md.scenario(0)).discountingProvider(); DiscountingFixedCouponBondTradePricer pricer = DiscountingFixedCouponBondTradePricer.DEFAULT; CurrencyAmount expectedPv = pricer.presentValue(RTRADE, provider); MultiCurrencyAmount expectedCurrencyExposure = pricer.currencyExposure(RTRADE, provider); CurrencyAmount expectedCurrentCash = pricer.currentCash(RTRADE, VAL_DATE); ISet <Measure> measures = ImmutableSet.of(Measures.PRESENT_VALUE, Measures.CURRENCY_EXPOSURE, Measures.CURRENT_CASH, Measures.RESOLVED_TARGET); assertThat(function.calculate(TRADE, measures, PARAMS, md, REF_DATA)).containsEntry(Measures.PRESENT_VALUE, Result.success(CurrencyScenarioArray.of(ImmutableList.of(expectedPv)))).containsEntry(Measures.CURRENCY_EXPOSURE, Result.success(MultiCurrencyScenarioArray.of(ImmutableList.of(expectedCurrencyExposure)))).containsEntry(Measures.CURRENT_CASH, Result.success(CurrencyScenarioArray.of(ImmutableList.of(expectedCurrentCash)))).containsEntry(Measures.RESOLVED_TARGET, Result.success(RTRADE)); }
public void GetHashCodeVariesByInstance() { Assert.NotEqual(ImmutableList.Create <int>().GetHashCode(), ImmutableList.Create(5).GetHashCode()); }
///------------------------------------------------------------------------------------------------- /// <summary> /// Constructor. /// </summary> /// <param name="services"> /// The services. /// </param> ///------------------------------------------------------------------------------------------------- public Subject(IServicesContainer services) { this._observers = new ImmutableList <IObserver <T> >(); _synchronizationContext = services.Resolve <ISynchronizationContext>(); }
public static LibKeyMap <TItem> Create(IEnumerable <TItem> items, Func <TItem, LibraryKey> getKeyFunc) { var itemsList = ImmutableList.ValueOf(items); return(new LibKeyMap <TItem>(itemsList, itemsList.Select(getKeyFunc))); }
public Todo Copy(ImmutableList <object> queue) { return(new Todo(Target, queue)); }
public LibKeyMap(ImmutableList <TItem> items, IEnumerable <LibraryKey> keys) { _allItems = items; _index = new LibKeyIndex(keys); }
public AddressBook(ImmutableList <Contact> contacts) => Contacts = contacts;
public rd1( ImmutableList <Ird1CrossJoinElement> value) { this.Value = value; }
// trusted constructor internal ResolvedSwap(ImmutableList <ResolvedSwapLeg> legs, ImmutableSet <Currency> currencies, ImmutableSet <Index> indices) { this.legs = legs; this.currencies = currencies; this.indices = indices; }
public void Add(T value) { var current = this.Current; var newSet = current.Add(value); if (newSet != current) { this.Subject.OnNext(new SortedSetChangedNotification <T>(newSet, NotifyCollectionChangedAction.Add, ImmutableList <T> .Empty, ImmutableList.Create(value), newSet.IndexOf(value))); } }
public Todo(IActorRef target, ImmutableList <object> queue) { Target = target; Queue = queue; }