/// <summary> /// Sets up the to chain. /// </summary> /// <param name="i">Current count.</param> /// <param name="logger">Logger class.</param> /// <param name="serviceProvider">DI service provider.</param> /// <returns>Returns an instance of the <see cref="IChain{T}"/> interface.</returns> private IChain <Routable> SetupToChain(int i, ILogger logger, IServiceProvider serviceProvider) { To toChain = new To(logger, this.GetToComponent(i, serviceProvider), this.GetIdentity()); logger.LogInformation(string.Format(Resources.INFO_SETUP_TO, toChain?.ToString())); if (i < this.toUris.Count - 1) { toChain.SetNext(this.SetupToChain(++i, logger, serviceProvider)); } else { IChain <Routable> atomic = null; IChain <Routable> error = null; if (this.atomicComponent != null) { logger.LogInformation(string.Format(Resources.INFO_SETUP_ATOMIC, this.atomicComponent.ToString())); atomic = new Atomic(logger, this.atomicComponent, this.GetIdentity()); } if (this.errorComponent != null) { logger.LogInformation(string.Format(Resources.INFO_SETUP_ERR, this.errorComponent.ToString())); error = new Chain.Error(logger, this.errorComponent, this.GetIdentity()); } toChain.SetNext(this.GetFinal(error, atomic)); } return(toChain); }
public override void Modify(IChain chain) { if (!chain.Middleware.OfType <TransactionalFrame>().Any()) { chain.Middleware.Add(new TransactionalFrame()); } }
public static IChain ChainFromFileOrCode(string file, PdbLoadOptions loadOptions = PdbLoadOptions.Default, char?chainId = null) { IEnumerable <AtomRecord> records = GetPdbRecords(file).Select(record => record as AtomRecord).Where(record => record as HetatmRecord == null); IChain chain = ChainFromRecords(records, loadOptions, chainId); return(chain); }
public static Matrix GetRmsdTransformForResidues(IChain move, int firstMoveResidue, int lastMoveResidue, IChain stationary, int firstStationaryResidue, int lastStationaryResidue) { Vector3[] stationaryCoordinates = new Vector3[(lastStationaryResidue - firstStationaryResidue + 1) * 3]; Vector3[] moveCoordinates = new Vector3[(lastMoveResidue - firstMoveResidue + 1) * 3]; int arrayIndex = 0; for (int residueIndex = firstStationaryResidue; residueIndex <= lastStationaryResidue; residueIndex++) { stationaryCoordinates[arrayIndex++] = stationary[residueIndex][Aa.N_].Xyz; stationaryCoordinates[arrayIndex++] = stationary[residueIndex][Aa.CA_].Xyz; stationaryCoordinates[arrayIndex++] = stationary[residueIndex][Aa.C_].Xyz; } arrayIndex = 0; for (int residueIndex = firstMoveResidue; residueIndex <= lastMoveResidue; residueIndex++) { moveCoordinates[arrayIndex++] = move[residueIndex][Aa.N_].Xyz; moveCoordinates[arrayIndex++] = move[residueIndex][Aa.CA_].Xyz; moveCoordinates[arrayIndex++] = move[residueIndex][Aa.C_].Xyz; } Matrix matrix = VectorMath.GetRmsdAlignmentMatrix(moveCoordinates, false, stationaryCoordinates, false); return(matrix); }
/// <summary> /// Returns sequence alignments that could join all of the input structures /// </summary> /// <param name="structures"></param> /// <param name="chains">IChain indices for each structure that should be </param> /// <returns></returns> public static TransformSequenceAlignment[][] GetRepeatFilteredTransformAlignments(IStructure[] structures, int[][] chains) { TransformSequenceAlignment[][] result = new TransformSequenceAlignment[structures.Length - 1][]; for (int i = 0; i < structures.Length - 1; i++) { List <TransformSequenceAlignment> alignments = new List <TransformSequenceAlignment>(); foreach (int chainIndex1 in chains[i]) { foreach (int chainIndex2 in chains[i + 1]) { IChain chain1 = structures[i][chainIndex1]; IChain chain2 = structures[i + 1][chainIndex2]; // Shorten the List <TransformSequenceAlignment> chainAlignments = GetRepeatFilteredTransformAlignments(structures[i], chainIndex1, false, structures[i + 1], chainIndex2, i != structures.Length - 2 && structures[i + 1].Count == 1, SS.Helix | SS.Extended); foreach (TransformSequenceAlignment alignment in chainAlignments) { alignment.ChainIndex1 = chainIndex1; alignment.ChainIndex2 = chainIndex2; } alignments.AddRange(chainAlignments); } } result[i] = alignments.ToArray(); } return(result); }
public static List <TransformSequenceAlignment> GetRepeatFilteredTransformAlignments( IChain chain1, bool fuseEndsOnly1, IChain chain2, bool fuseEndsOnly2, SS allowedTypes, int minAlignmentLength = DefaultMinAlignmentLength, float maxRmsd = DefaultRmsdThreshold) { List <TransformSequenceAlignment> alignments = GetTransformAlignments(chain1, chain2, allowedTypes, minAlignmentLength, maxRmsd); if (fuseEndsOnly1) { int repeatLength1; if (Sequence.TryGetInternalRepeatLength(chain1, out repeatLength1) && repeatLength1 > 15) { alignments.RemoveAll(a => (a.Range1.Start > 1.15 * repeatLength1) && (a.Range1.End < chain1.Count - 1.15 * repeatLength1)); } } if (fuseEndsOnly2) { int repeatLength2; if (Sequence.TryGetInternalRepeatLength(chain2, out repeatLength2) && repeatLength2 > 15) { alignments.RemoveAll(a => (a.Range2.Start > 1.15 * repeatLength2) && (a.Range2.End < chain1.Count - 1.15 * repeatLength2)); } } return(alignments); }
/// <summary> /// /// </summary> /// <param name="nChain">The peptide that will be constitute the N-terminal region of the resultant spliced peptide</param> /// <param name="cChain">The peptide that will be constitute the C-terminal region of the resultant spliced peptide</param> /// <param name="nInclude">The included portion of the N-terminal peptide</param> /// <param name="cInclude">The included portion of hte C-terminal peptide</param> /// <param name="nAlignNullable">The region to align on prior to splicing</param> /// <param name="cAlignNullable">The region to align on prior to splicing</param> /// <returns></returns> public static IChain GetPeptide(IChain nChain, IChain cChain, Range nInclude, Range cInclude, Range?nAlignNullable = null, Range?cAlignNullable = null) { bool performAlignment = nAlignNullable != null && cAlignNullable != null; Range nAlign = performAlignment ? new Range((Range)nAlignNullable) : new Range(); Range cAlign = performAlignment ? new Range((Range)cAlignNullable) : new Range(); if (performAlignment && ((Range)nAlignNullable).Length != ((Range)cAlignNullable).Length) { throw new ArgumentException("Splice ranges must be of equal length"); } if (nInclude.Start < 0 || nChain.Count <= nInclude.End || cInclude.Start < 0 || cChain.Count <= cInclude.End) { throw new IndexOutOfRangeException("Splice ranges exceed the peptide ranges"); } IChain chain = new Chain(); //float rmsd = Rmsd.GetRmsd(cTerminus[cAlign.Start, cAlign.End], nTerminus[nAlign.Start, nAlign.End]); Matrix cTerminusTransform = performAlignment ? Rmsd.GetRmsdTransform(cChain[cAlign.Start, cAlign.End], nChain[nAlign.Start, nAlign.End]) : Matrix.Identity; cTerminusTransform.Rotation.Normalize(); //Quaternion rotation = cTerminusTransform.Rotation; //rotation.Normalize(); //cTerminusTransform.Rotation = rotation; for (int i = nInclude.Start; i <= nInclude.End; i++) { chain.Add(new Aa(nChain[i])); } for (int i = cInclude.Start; i <= cInclude.End; i++) { IAa residue = new Aa(cChain[i]); residue.Transform(cTerminusTransform); chain.Add(residue); } return(chain); }
private void VisitChain(IChain <MethodReferenceAdaptor, FieldReferenceAdaptor, TypeReferenceAdaptor> c) { Contract.Requires(c != null); switch (c.Tag) { case ChainTag.Type: var t = c.Type.reference.ResolvedType; this.thingsToKeep.Add(t); var ntr = t as INamespaceTypeReference; if (ntr != null) { this.AddUpwardNamespace(ntr.ContainingUnitNamespace); } foreach (var child in c.Children) { this.VisitChain(child); } break; case ChainTag.Field: this.thingsToKeep.Add(c.Field.reference.ResolvedField); break; case ChainTag.Method: var m = c.Method.reference.ResolvedMethod; this.thingsToKeep.Add(m); this.methodHashAttributes.Add(m, c.MethodHashAttribute); break; default: Contract.Assume(false, "switch should be exhaustive"); break; } }
public static void CheckIfChainIsFresh(IChain chain, bool acceptStaleRequests) { if (!acceptStaleRequests && chain.IsStale) { throw new HttpStatusCodeException(HttpStatusCode.InternalServerError, "Node is still synchronizing; API cannot be used yet"); } }
private void DoSettlement(IChain sourceChain, Address sourceAddress, Address targetAddress, string symbol, BigInteger value, byte[] data) { Runtime.Expect(value > 0, "value must be greater than zero"); Runtime.Expect(targetAddress.IsUser, "target must not user address"); Runtime.Expect(this.Runtime.TokenExists(symbol), "invalid token"); var tokenInfo = this.Runtime.GetToken(symbol); /*if (tokenInfo.IsCapped()) * { * var supplies = new SupplySheet(symbol, this.Runtime.Chain, Runtime.Nexus); * * if (IsAddressOfParentChain(sourceChain.Address)) * { * Runtime.Expect(supplies.MoveFromParent(this.Storage, value), "target supply check failed"); * } * else // child chain * { * Runtime.Expect(supplies.MoveFromChild(this.Storage, sourceChain.Name, value), "target supply check failed"); * } * } */ if (tokenInfo.IsFungible()) { Runtime.SwapTokens(sourceChain.Name, sourceAddress, Runtime.Chain.Name, targetAddress, symbol, value, null, null); } else { var nft = Serialization.Unserialize <PackedNFTData>(data); Runtime.SwapTokens(sourceChain.Name, sourceAddress, Runtime.Chain.Name, targetAddress, symbol, value, nft.ROM, nft.RAM); } }
/// <summary> /// Build this controller. /// </summary> /// <param name="config"> Higher level API configuration. </param> /// <param name="chain"> Executor's chain instance from bitprim-cs library. </param> /// <param name="memoryCache"> Abstract. </param> /// <param name="poolsInfo"> For recognizing blocks which come from mining pools. </param> public BlockController(IOptions <NodeConfig> config, IChain chain, IMemoryCache memoryCache, IPoolsInfo poolsInfo) { config_ = config.Value; chain_ = chain; memoryCache_ = memoryCache; poolsInfo_ = poolsInfo; }
public DotnetWrapperService( [NotNull] IChain <IProcessWrapper> processChain, [NotNull] IFileSystem fileSystem) { _processChain = processChain ?? throw new ArgumentNullException(nameof(processChain)); _fileSystem = fileSystem ?? throw new ArgumentNullException(nameof(fileSystem)); }
/// <summary> /// Build this controller. /// </summary> /// <param name="config"> Higher level API configuration. </param> /// <param name="executor"> Node executor from bitprim-cs library. </param> /// <param name="logger"> Abstract logger. </param> public AddressController(IOptions <NodeConfig> config, Executor executor, ILogger <AddressController> logger) { nodeExecutor_ = executor; chain_ = nodeExecutor_.Chain; config_ = config.Value; logger_ = logger; }
private string GetNodesDescription(IChain <MessageInfo, LinkInfo <T> > map) { var sb = new StringBuilder(); foreach (var node in map.Nodes) { var processedNode = new Node <MessageInfo>(node) { Attributes = new Dictionary <string, string>(4) }; foreach (var nodeRule in _theme.DefaultNodeRules()) { nodeRule.Process(processedNode, _theme.DefaultNodeRules(), map); } if (!string.IsNullOrEmpty(processedNode.Comments)) { sb.AppendLine($"/* {processedNode.Comments} */"); } var additional = string.Empty; if (processedNode.Attributes.Count > 0) { additional = $"[{string.Join(", ", processedNode.Attributes.Select(x => $"{x.Key.ToLower()}={CheckAndWrapQuotes(x.Value)}").ToArray())}]"; } sb.AppendLine($"{processedNode.Name}{additional};"); } return(sb.ToString()); }
private string ProcessChain(IChain <MessageInfo, LinkInfo <T> > chain) { var sb = new StringBuilder(); foreach (var edge in chain.Edges) { sb.AppendLine(); var attributes = new Dictionary <string, string>(); if (!string.IsNullOrEmpty(edge.Info.Label)) { attributes.Add(GraphvizAttribute.Label.ToString(), edge.Info.Label); } foreach (var linkRule in _theme.DefaultLinkRules()) { linkRule.Process(edge, attributes, chain); } sb.Append($"{edge.FromId.NormalizeGraphvizNames()} -> {edge.ToId.NormalizeGraphvizNames()}"); if (attributes.Count > 0) { sb.Append($"[{string.Join(", ", attributes.Select(x => $"{x.Key.ToLower()}={CheckAndWrapQuotes(x.Value)}").ToArray())}]"); } sb.Append(";"); } sb.AppendLine(); return(sb.ToString()); }
/// <summary> /// Notifies all subscribers of the new chain /// </summary> /// <param name="chain">The new message handler Chain</param> public void Notify(IChain chain) { foreach (var s in this.eventSubscribers) { s(chain); } }
public static Selection GetContactSelectionInFocusSet(IList <IChain> focus, IList <IChain> other, ContactType contactType = ContactType.Atomic) { Selection selection = new Selection(); for (int focusIndex = 0; focusIndex < focus.Count; focusIndex++) { for (int otherIndex = 0; otherIndex < other.Count; otherIndex++) { IChain focusChain = focus[focusIndex]; IChain otherChain = other[otherIndex]; for (int focusAaIndex = 0; focusAaIndex < focusChain.Count; focusAaIndex++) { IAa aaFocus = focusChain[focusAaIndex]; for (int otherAaIndex = 0; otherAaIndex < otherChain.Count; otherAaIndex++) { IAa aaOther = otherChain[otherAaIndex]; Trace.Assert(aaFocus != aaOther); if (AnyContact(aaFocus, aaOther, contactType)) { selection.Aas.Add(aaFocus); break; } } } } } return(selection); }
public static Selection GetContactSelection(IChain[] chains, ContactType contactType = ContactType.Atomic) { Selection selection = new Selection(); for (int chainIndex1 = 0; chainIndex1 < chains.Length - 1; chainIndex1++) { for (int chainIndex2 = chainIndex1 + 1; chainIndex2 < chains.Length; chainIndex2++) { IChain chain1 = chains[chainIndex1]; IChain chain2 = chains[chainIndex2]; Trace.Assert(chain1 != chain2); for (int aaIndex1 = 0; aaIndex1 < chain1.Count; aaIndex1++) { IAa aa1 = chain1[aaIndex1]; for (int aaIndex2 = 0; aaIndex2 < chain2.Count; aaIndex2++) { IAa aa2 = chain2[aaIndex2]; Trace.Assert(aa1 != aa2); if (AnyContact(aa1, aa2, contactType)) { selection.Aas.Add(aa1); selection.Aas.Add(aa2); } } } } } return(selection); }
public DictionaryLP(int input) { mod = input; hastValue = new HashTechnique_2(); DictionaryArr = new Node[input]; this.chain = new ChainLenierProbing(input); }
public void ApplyTransactionSupport(IChain chain) { if (!chain.Middleware.OfType <TransactionalFrame>().Any()) { chain.Middleware.Add(new TransactionalFrame()); } }
public static List <SSBlock> GetPhiPsiSSBlocksOfType(IChain peptide, SS allowedTypes, int minStructureLength = 1) { List <SSBlock> list = GetPhiPsiSSBlocks(peptide, minStructureLength); List <SSBlock> matchingTypeList = list.Where(block => (block.SS & allowedTypes) != 0).ToList(); return(matchingTypeList); }
public static Matrix GetRmsdAndTransform(IChain move, int moveStart, int moveEnd, IChain stationary, int stationaryStart, int stationaryEnd, out float rmsd) { Matrix transform = Rmsd.GetRmsdTransformForResidues(move, moveStart, moveEnd, stationary, stationaryStart, stationaryEnd); rmsd = GetRmsdNCAC(transform, move, moveStart, moveEnd, stationary, stationaryStart, stationaryEnd); return(transform); }
public static float GetRmsdNCAC(IChain peptide1, int rangeStart1, int rangeEnd1, IChain peptide2, int rangeStart2, int rangeEnd2) { Matrix transform = Rmsd.GetRmsdTransformForResidues(peptide1, rangeStart1, rangeEnd1, peptide2, rangeStart2, rangeEnd2); float rmsd = GetRmsdNCAC(transform, peptide1, rangeStart1, rangeEnd1, peptide2, rangeStart2, rangeEnd2); return(rmsd); }
private static void VisitChain(IChain <MethodReferenceAdaptor, FieldReferenceAdaptor, TypeReferenceAdaptor> c, MetadataTraverser mt) { Contract.Requires(c != null); Contract.Requires(mt != null); switch (c.Tag) { case ChainTag.Type: { Contract.Assume(c.Children != null, "The code makes such an assumption"); foreach (var child in c.Children) { VisitChain(child, mt); } } break; case ChainTag.Field: { Contract.Assume(c.Field.reference != null); mt.Traverse(c.Field.reference); } break; case ChainTag.Method: { Contract.Assume(c.Method.reference != null); mt.Traverse(c.Method.reference); } break; default: Contract.Assert(false, "switch should be exhaustive"); break; } }
public static List <Vector3> GetHelixVectors(IChain peptide, IEnumerable <SSBlock> blocks) { List <Vector3> vectors = new List <Vector3>(); foreach (SSBlock block in blocks.Where(b => b.SS == SS.Helix)) { Vector3 start = peptide[block.Start][Aa.CA_].Xyz; Vector3 end = peptide[block.End][Aa.CA_].Xyz; if (18 < block.Length) { end = peptide[block.Start + 18][Aa.CA_].Xyz; } else if (11 < block.Length) { end = peptide[block.Start + 11][Aa.CA_].Xyz; } else if (7 < block.Length) { end = peptide[block.Start + 7][Aa.CA_].Xyz; } Vector3 vec = end - start; vectors.Add(vec); } return(vectors); }
public Engine(IoCContainer container) { _container = container; #if DEBUG_REFERENCES SharpDX.Configuration.EnableObjectTracking = true; SharpDX.Configuration.EnableReleaseOnFinalizer = true; #endif IDeviceContextService deviceContextService = _container.Resolve <IDeviceContextService>(); _form = deviceContextService.Form; _context = deviceContextService.Context; _form.Icon = Resources.openuo; _form.Text = string.Format("OpenUO v{0}", new AssemblyInfo(Assembly.GetEntryAssembly()).Version); _form.ResizeBegin += OnResizeBegin; _form.ResizeEnd += OnResizeEnd; _form.FormClosed += OnFormClosed; _updateState = new UpdateState(); _gameTime = new GameTime(); _world = new World(container); container.Resolve <IConsole>().WriteLine("Testing 123"); _config = _container.Resolve <IConfiguration>(); _updateChain = _container.Resolve <IChain <UpdateState> >(); _worldRenderChain = _container.Resolve <IWorldRenderChain>(); _uiRenderChain = _container.Resolve <IUIRenderChain>(); _screenTarget = new DrawScreenTarget(_context); _updateChain.Freeze(); _worldRenderChain.Freeze(); _uiRenderChain.Freeze(); }
public void UnionWith(IChain chain) { _chains.Add(chain); foreach (IAa aa in chain) { this.UnionWith(aa); } }
public void AppendTo(IChain parent) { if (parent == null) { throw new ArgumentNullException("parent"); } Parent = parent; }
public StopwatchFrame(IChain chain) { _chain = chain; // This frame creates a Stopwatch, so we // expose that fact to the rest of the generated method // just in case someone else wants that _stopwatch = new Variable(typeof(Stopwatch), "stopwatch", this); }
public void ChainBuilt(IChain chain) { var subscriptionNotification = new ChainBuilderNotifier(); var services = new ChainBuilderSetupServices(subscriptionNotification); var chainFunc = this.newchainBuilder.BuildFunc(services); this.newChain = new Chain <TNewMessageType>(chainFunc, chain.Dispose); subscriptionNotification.Notify(this.newChain); }
public void GivenAListOfRules(Table table) { var rules = table.CreateSet<Rule>(); chain = new Chain(); rules.ToList().ForEach(r => { chain.Add(r); }); chain["Rule 1"].Apply = (c) => c.Amount < 200; chain["Rule 2"].Apply = (c) => c.Amount > 400 && c.Amount < 600; chain["Rule 3"].Apply = (c) => c.Amount > 600 && c.Amount < 800; chain["Rule 4"].Apply = (c) => c.Amount > 800 && c.Amount < 1000; chain["Rule 5"].Apply = (c) => c.Amount > 1000; }
public void SetCurrentChain(IChain chain) { if (_currentChain != chain) { listView1.Items.Clear(); if ((_currentChain = chain) != null) { foreach (var frame in chain.GetFrames()) listView1.Items.Add(new CallStackListViewItem(frame)); } } else { UpdateCurrentFrames(); } }
public void SetUp() { chain = new Chain(); }
public void Add(IChain handler) { this.list.Add(handler); }
private void VisitChain(IChain<MethodReferenceAdaptor, FieldReferenceAdaptor, TypeReferenceAdaptor> c) { Contract.Requires(c != null); switch (c.Tag) { case ChainTag.Type: var t = c.Type.reference.ResolvedType; this.thingsToKeep.Add(t); var ntr = t as INamespaceTypeReference; if (ntr != null) { this.AddUpwardNamespace(ntr.ContainingUnitNamespace); } foreach (var child in c.Children) this.VisitChain(child); break; case ChainTag.Field: this.thingsToKeep.Add(c.Field.reference.ResolvedField); break; case ChainTag.Method: var m = c.Method.reference.ResolvedMethod; this.thingsToKeep.Add(m); this.methodHashAttributes.Add(m, c.MethodHashAttribute); break; default: Contract.Assume(false, "switch should be exhaustive"); break; } }
public Engine(IoCContainer container) { _container = container; #if DEBUG_REFERENCES SharpDX.Configuration.EnableObjectTracking = true; SharpDX.Configuration.EnableReleaseOnFinalizer = true; #endif IDeviceContextService deviceContextService = _container.Resolve<IDeviceContextService>(); _form = deviceContextService.Form; _context = deviceContextService.Context; _form.Icon = Resources.openuo; _form.Text = string.Format("OpenUO v{0}", new AssemblyInfo(Assembly.GetEntryAssembly()).Version); _form.ResizeBegin += OnResizeBegin; _form.ResizeEnd += OnResizeEnd; _form.FormClosed += OnFormClosed; _updateState = new UpdateState(); _gameTime = new GameTime(); _world = new World(container); container.Resolve<IConsole>().WriteLine("Testing 123"); _config = _container.Resolve<IConfiguration>(); _updateChain = _container.Resolve<IChain<UpdateState>>(); _worldRenderChain = _container.Resolve<IWorldRenderChain>(); _uiRenderChain = _container.Resolve<IUIRenderChain>(); _screenTarget = new DrawScreenTarget(_context); _updateChain.Freeze(); _worldRenderChain.Freeze(); _uiRenderChain.Freeze(); }
// Defines the next Object to receive the // data if this one can't use it public void setNextChain(IChain nextChain) { nextInChain = nextChain; }
public Service(IInvoiceRepository invoiceRepository, IClientRepository clientRepository, IChain chain) { _invoiceRepository = invoiceRepository; _clientRepository = clientRepository; _chain = chain; }
public HDoc(IChain<HAttribute> attributes, IEnumerable<object> children) : base("html", attributes, children) { }
public void Initialize() { chain = new Chain(); }
public MyChain4(IChain chain) { }
public MyChain2(IChain chain) { }
public MyChain(IChain chain) { }
public HElement(string name, IChain<HAttribute> attributes, IEnumerable<object> children) : base(children) { this.Name = name; if (attributes != null) Attributes = attributes.ToEnumerable ().Where (a => a.Value != null).ToList (); Validate (); }
private static void VisitChain(IChain<MethodReferenceAdaptor, FieldReferenceAdaptor, TypeReferenceAdaptor> c, MetadataTraverser mt) { Contract.Requires(c != null); Contract.Requires(mt != null); switch (c.Tag) { case ChainTag.Type: { Contract.Assume(c.Children != null, "The code makes such an assumption"); foreach (var child in c.Children) VisitChain(child, mt); } break; case ChainTag.Field: { Contract.Assume(c.Field.reference != null); mt.Traverse(c.Field.reference); } break; case ChainTag.Method: { Contract.Assume(c.Method.reference!= null); mt.Traverse(c.Method.reference); } break; default: Contract.Assert(false, "switch should be exhaustive"); break; } }