public IActionResult Send( [FromQuery(Name = "api_id")] Guid apiId, [FromQuery] String from, [FromQuery] Int32 json, [FromQuery(Name = "msg")] String encodedMsg, [FromQuery] String to ) { var msg = Uri.UnescapeDataString(encodedMsg); var phone = new Phone(to); this._logger.LogInformation($"Received message to {phone}"); var account = this.Find(from); var cascade = new Cascade( this.CreateValidators( account, phone ) ); this.TryToSaveMessage(new Sms { Message = msg, To = phone.ToString() }, cascade.Answer()); return(new OkObjectResult( new OkFromSmsRu( phone, cascade.Answer(), account ) )); }
public OrderMapping(Cascade productsCascade, Cascade fkProductsCascade) { Property(o => o.Status, o => o.NotNullable(true)); Property(o => o.Name, o => { o.NotNullable(true); o.Length(20); }); Property(o => o.TotalPrice, o => o.NotNullable(true)); Property(o => o.Active, o => o.NotNullable(true)); Component(o => o.Address, o => { o.Property(c => c.City); o.Property(c => c.Country); o.Property(c => c.HouseNumber); o.Property(c => c.Street); }); Set(o => o.Products, o => { o.Key(k => k.Column("OrderId")); o.Inverse(true); o.Cascade(productsCascade); o.Lazy(CollectionLazy.Extra); }, o => o.OneToMany()); Set(o => o.FkProducts, o => { o.Key(k => k.Column("OrderId")); o.Inverse(true); o.Cascade(fkProductsCascade); o.Lazy(CollectionLazy.Extra); }, o => o.OneToMany()); }
private async Task <Cascade <int> > GetCascadeAsync(SiteSummary summary, Func <SiteSummary, Task <object> > func = null) { object extra = null; if (func != null) { extra = await func(summary); } var cascade = new Cascade <int> { Value = summary.Id, Label = summary.SiteName, Children = await GetCascadeChildrenAsync(summary.Id, func) }; if (extra == null) { return(cascade); } var dict = TranslateUtils.ToDictionary(extra); foreach (var o in dict) { cascade[o.Key] = o.Value; } return(cascade); }
public void SimplePropertyAccess_GetCustomMember_FixedAttributeProxy() { const string scriptFunctionSourceCode = @" import clr def PropertyPathAccess(cascade) : return cascade.GetName() "; const int numberChildren = 10; var cascade = new Cascade(numberChildren); var attributeNameProxy = _scriptContext.GetAttributeProxy(cascade, "GetName"); var cascadeGetCustomMemberReturnsFixedAttributeProxy = new CascadeGetCustomMemberReturnsFixedAttributeProxy(numberChildren, attributeNameProxy); var privateScriptEnvironment = ScriptEnvironment.Create(); privateScriptEnvironment.Import(typeof(Cascade).Assembly.GetName().Name, typeof(Cascade).Namespace, typeof(Cascade).Name); var propertyPathAccessScript = new ScriptFunction <Cascade, string> ( _scriptContext, ScriptLanguageType.Python, scriptFunctionSourceCode, privateScriptEnvironment, "PropertyPathAccess" ); //var nrLoopsArray = new[] { 1, 1, 10, 100, 1000, 10000, 100000, 1000000 }; var nrLoopsArray = new[] { 1, 1, 10, 100, 1000, 10000, 100000 }; ScriptingHelper.ExecuteAndTime("script function", nrLoopsArray, () => propertyPathAccessScript.Execute(cascade)); ScriptingHelper.ExecuteAndTime("script function (FixedAttributeProxy)", nrLoopsArray, () => propertyPathAccessScript.Execute(cascadeGetCustomMemberReturnsFixedAttributeProxy)); }
public void SimplePropertyAccess_GetCustomMember2() { const string scriptFunctionSourceCode = @" import clr def PropertyPathAccess(cascade) : return cascade.Child.Child.Child.Child.Child.Child.Child.Child.Child.Name "; const int numberChildren = 10; var cascade = new Cascade(numberChildren); var cascadeStableBinding = new CascadeStableBinding(numberChildren); var cascadeStableBindingFromMixin = ObjectFactory.Create <CascadeStableBindingFromMixin> (ParamList.Create(numberChildren)); var privateScriptEnvironment = ScriptEnvironment.Create(); privateScriptEnvironment.Import(typeof(TestDomain.Cascade).Assembly.GetName().Name, typeof(TestDomain.Cascade).Namespace, typeof(TestDomain.Cascade).Name); var propertyPathAccessScript = new ScriptFunction <Cascade, string> ( _scriptContext, ScriptLanguageType.Python, scriptFunctionSourceCode, privateScriptEnvironment, "PropertyPathAccess" ); var nrLoopsArray = new[] { 1, 1, 100000 }; ScriptingHelper.ExecuteAndTime("SimplePropertyAccess_GetCustomMember2 (No StableBinding)", nrLoopsArray, () => propertyPathAccessScript.Execute(cascade)); ScriptingHelper.ExecuteAndTime("SimplePropertyAccess_GetCustomMember2 (StableBinding from Mixin)", nrLoopsArray, () => propertyPathAccessScript.Execute(cascadeStableBindingFromMixin)); ScriptingHelper.ExecuteAndTime("SimplePropertyAccess_GetCustomMember2 (StableBinding)", nrLoopsArray, () => propertyPathAccessScript.Execute(cascadeStableBinding)); }
public void BoardTest() { foreach (FreeSpace space in board.FreeSpaces) { Assert.AreEqual(0, space.CardList.Count); } int totalCards = 0; for (int i = 0; i < 4; i++) { Cascade casc = board.Cascades[i]; totalCards = totalCards + casc.CardList.Count; Assert.AreEqual(7, casc.CardList.Count); } for (int i = 4; i < 8; i++) { Cascade casc = board.Cascades[i]; totalCards = totalCards + casc.CardList.Count; Assert.AreEqual(6, casc.CardList.Count); } Assert.AreEqual(52, totalCards); Assert.AreEqual(false, board.Foundations[Suit.Spades] == null); Assert.AreEqual(0, board.Foundations[Suit.Spades].CardList.Count); Assert.AreEqual(false, board.Foundations[Suit.Hearts] == null); Assert.AreEqual(0, board.Foundations[Suit.Hearts].CardList.Count); Assert.AreEqual(false, board.Foundations[Suit.Diamonds] == null); Assert.AreEqual(0, board.Foundations[Suit.Diamonds].CardList.Count); Assert.AreEqual(false, board.Foundations[Suit.Clubs] == null); Assert.AreEqual(0, board.Foundations[Suit.Clubs].CardList.Count); }
private async Task GetDirectoriesAndFilesAsync(List <Cascade <string> > directories, List <KeyValuePair <string, string> > files, Site site, string virtualPath, string extName) { extName = "." + extName; var directoryPath = await _pathManager.GetSitePathAsync(site, virtualPath); DirectoryUtils.CreateDirectoryIfNotExists(directoryPath); var fileNames = DirectoryUtils.GetFileNames(directoryPath); foreach (var fileName in fileNames) { if (StringUtils.EqualsIgnoreCase(PathUtils.GetExtension(fileName), extName)) { files.Add(new KeyValuePair <string, string>(virtualPath, fileName)); } } var dir = new Cascade <string> { Label = PathUtils.GetDirectoryName(directoryPath, false), Value = virtualPath }; var children = DirectoryUtils.GetDirectoryNames(directoryPath); dir.Children = new List <Cascade <string> >(); foreach (var directoryName in children) { await GetDirectoriesAndFilesAsync(dir.Children, files, site, PageUtils.Combine(virtualPath, directoryName), extName); } directories.Add(dir); }
public void SimplePropertyAccess_GetCustomMember() { const string scriptFunctionSourceCode = @" import clr def PropertyPathAccess(cascade) : return cascade.Child.Child.Child.Child.Child.Child.Child.Child.Child.Name "; const int numberChildren = 10; var cascadeWithoutStableBinding = new Cascade(numberChildren); var cascadeStableBinding = new CascadeStableBinding(numberChildren); var privateScriptEnvironment = ScriptEnvironment.Create(); privateScriptEnvironment.Import(typeof(TestDomain.Cascade).Assembly.GetName().Name, typeof(TestDomain.Cascade).Namespace, typeof(TestDomain.Cascade).Name); var propertyPathAccessScript = new ScriptFunction <Cascade, string> ( _scriptContext, ScriptLanguageType.Python, scriptFunctionSourceCode, privateScriptEnvironment, "PropertyPathAccess" ); //var nrLoopsArray = new[] { 1, 1, 10000 }; var nrLoopsArray = new[] { 1, 1, 100000 }; // Warm up ScriptingHelper.ExecuteAndTime(nrLoopsArray, () => propertyPathAccessScript.Execute(cascadeStableBinding)).Last(); double timingStableBinding = ScriptingHelper.ExecuteAndTime(nrLoopsArray, () => propertyPathAccessScript.Execute(cascadeStableBinding)).Last(); double timingWithoutStableBinding = ScriptingHelper.ExecuteAndTime(nrLoopsArray, () => propertyPathAccessScript.Execute(cascadeWithoutStableBinding)).Last(); //To.ConsoleLine.e (() => timingStableBinding).e (() => timingWithoutStableBinding); //To.ConsoleLine.e ("timingStableBinding / timingWithoutStableBinding = ", timingStableBinding / timingWithoutStableBinding); Assert.That(timingStableBinding / timingWithoutStableBinding, Is.LessThan(7.0)); }
// Use this for initialization void Start() { manager = this; for (int i = 0; i < 7; i++) { var obj = Instantiate(placeholderPrefab) as GameObject; BoxCollider boxCollider = obj.GetComponent <BoxCollider>(); Cascade cascade = obj.GetComponent <Cascade>(); cascades.Add(cascade); cascade.transform.parent = cascadesTransform; cascade.cardsRootTransform.parent = cascadeCardsTransform; float width = boxCollider.bounds.size.x; cascade.transform.localPosition = new Vector3(i * (width + spacing), 0, 0); cascade.cardsRootTransform.localPosition = new Vector3(i * (width + spacing), 0, 0); cascade.transform.rotation = obj.transform.parent.rotation; cascade.cardsRootTransform.rotation = cascadeCardsTransform.rotation; obj.transform.localRotation *= Quaternion.AngleAxis(-90, new Vector3(1, 0, 0)); allPlaceholders.Add(cascade); } //acePiles.AddRange(new List<AcePile>{wands,cups,swords,coins}); allPlaceholders.AddRange(from p in acePiles select(Placeholder) p); allPlaceholders.AddRange(from p in cascades select(Placeholder) p); allPlaceholders.Add(deck); allPlaceholders.Add(hand); allPlaceholders.Add(discard); hand.deck = deck; hand.discard = discard; deck.hand = hand; deck.discard = discard; }
public ActionResult Index(Cascade cas) { tblstud stud = new tblstud(); if (ModelState.IsValid) { try { stud.name = cas.getstu.name; stud.address = cas.getstu.address; stud.gender = cas.getstu.gender; stud.stateid = cas.StateId; stud.cityid = cas.CityId; cas.getstu = stud; sd.tblstuds.Add(stud); sd.SaveChanges(); State_Bind(); } catch { State_Bind(); return(View(cas)); } } return(View(cas)); }
private static IEnumerable <string> CascadeDefinitions(this Cascade source) { if (source.Has(Cascade.All)) { yield return("all"); } if (source.Has(Cascade.Persist)) { yield return("save-update, persist"); } if (source.Has(Cascade.Refresh)) { yield return("refresh"); } if (source.Has(Cascade.Merge)) { yield return("merge"); } if (source.Has(Cascade.Remove)) { yield return("delete"); } if (source.Has(Cascade.Detach)) { yield return("evict"); } if (source.Has(Cascade.ReAttach)) { yield return("lock"); } if (source.Has(Cascade.DeleteOrphans)) { yield return("delete-orphan"); } }
public void LongPropertyPathAccess_StableBinding() { const string scriptFunctionSourceCode = @" import clr def PropertyPathAccess(cascade) : if cascade.GetChild().GetChild().GetChild().GetChild().GetChild().GetChild().GetChild().GetChild().GetChild().GetName() == 'C0' : return cascade.GetChild().GetChild().GetChild().GetChild().GetChild().GetChild().GetChild().GetName() return 'FAILED' "; const int numberChildren = 10; var cascade = new Cascade(numberChildren); var cascadeStableBinding = new CascadeStableBinding(numberChildren); //var cascadeStableBinding = ObjectFactory.Create<CascadeStableBinding> (ParamList.Create (numberChildren)); var privateScriptEnvironment = ScriptEnvironment.Create(); privateScriptEnvironment.Import(typeof(Cascade).Assembly.GetName().Name, typeof(Cascade).Namespace, typeof(Cascade).Name); var propertyPathAccessScript = new ScriptFunction <Cascade, string> ( _scriptContext, ScriptLanguageType.Python, scriptFunctionSourceCode, privateScriptEnvironment, "PropertyPathAccess" ); //var nrLoopsArray = new[] { 1, 1, 10, 100, 1000, 10000, 100000, 1000000 }; var nrLoopsArray = new[] { 1, 1, 10, 100, 1000, 10000 }; ScriptingHelper.ExecuteAndTime("script function", nrLoopsArray, () => propertyPathAccessScript.Execute(cascade)); ScriptingHelper.ExecuteAndTime("script function (stable binding)", nrLoopsArray, () => propertyPathAccessScript.Execute(cascadeStableBinding)); }
public static Cascade Exclude(this Cascade source, Cascade value) { if (source.Has(Cascade.All) && !value.Has(Cascade.All)) { return(Cleanup(((source & ~Cascade.All) | AnyButOrphans) & ~value)); } return(Cleanup(source & ~value)); }
public void CascadeTest() { Cascade cascade = new Cascade(); double actual = cascade.ComputeLength(testArray); Assert.AreEqual(result, actual); }
public static Cascade Exclude(this Cascade source, Cascade value) { if (source.Has(Cascade.All) && !value.Has(Cascade.All)) { return Cleanup(((source & ~Cascade.All) | AnyButOrphans) & ~value); } return Cleanup(source & ~value); }
/// <summary> /// Constructs a new Midi Processor. /// </summary> /// <param name="plugin">Must not be null.</param> public MidiProcessor(Plugin plugin) { _plugin = plugin; Cascade = new Cascade(plugin); // for most hosts, midi output is expected during the audio processing cycle. SyncWithAudioProcessor = true; }
/// <summary> /// Gets the child entities which would be affected by the specified cascade. /// </summary> /// <param name="entity">The entity.</param> /// <param name="cascade">The cascade.</param> /// <returns>Returns a list of entities.</returns> public List <Entity> GetChildEntities(Entity entity, Cascade cascade) { var entities = new List <Entity>(); GetChildEntities(entity, cascade, entities); return(entities); }
public ManyToManyAttribute( Type childType, Mapping.Loading loading, Cascade cascade ) : base() { this.ChildReturnType = childType; this.Linked = true; this.Loading = loading; this.Cascade = cascade; }
protected override Message ReceiveAuthenticatedMessage(AuthenticatedMessage message) { if (message is BlocksParityRequest) { var blockParityRequestMessage = message as BlocksParityRequest; var blocksPayload = message.Payload as Blocks; for (int i = 0; i < blocksPayload.BlocksArray.Length; i++) { var block = blocksPayload.BlocksArray[i]; var parity = Cascade.Parity(DestilationBuffer.GetBits(block.Index, block.Length)); blocksPayload.BlocksArray[i].Parity = parity; } var mac = MessageAuthenticator.GetMAC(blocksPayload.GetBytes()); return(new BlocksParityResponse(mac, blocksPayload)); } if (message is CheckParity) { var checkParityMessage = message as CheckParity; var blockIdentification = checkParityMessage.Payload as BlockIdentifiaction; var parity = Cascade.Parity(DestilationBuffer.GetBits(blockIdentification.Index, blockIdentification.Length)); var payload = new ParityPayload(blockIdentification.Index, blockIdentification.Length, parity); var mac = MessageAuthenticator.GetMAC(payload.GetBytes()); return(new Parity(mac, payload)); } if (message is RequestBits) { var requestBitsMessage = message as RequestBits; var blockIdentification = requestBitsMessage.Payload as BlockIdentifiaction; var bytes = DestilationBuffer.GetBytes(blockIdentification.Index, blockIdentification.Length); var payload = new BitsAsBytes(blockIdentification.Index, blockIdentification.Length, bytes); var mac = MessageAuthenticator.GetMAC(payload.GetBytes()); return(new Bytes(mac, payload, requestBitsMessage.Demand)); } if (message is AddKey) { var addKeyMessage = message as AddKey; var messagPayload = (addKeyMessage.Payload as BlockIdAndKeyAllocation); if (messagPayload.BlockId == _currentKeyChunk + 1) { var key = LocalKeyStore.GetKey(); CommonKeyStore.AddNewKey(key, messagPayload.KeyAllocation); _currentKeyChunk += 1; return(PrepareAckForCommonKeyProposition(_currentKeyChunk)); } else { if (messagPayload.BlockId == _currentKeyChunk) { return(PrepareAckForCommonKeyProposition(_currentKeyChunk)); } else { return(new NOP()); } } } return(new NOP()); }
public Cascade(int nrChildren) { --nrChildren; _name = "C" + nrChildren; if (nrChildren > 0) { Child = new Cascade(nrChildren); } }
/// <summary> /// Instantiates a new instance of the <see cref="T:ManyToManyAttribute"/> defining a many to many relationship. /// </summary> /// <param name="childTable">The table name of the child.</param> /// <param name="linkingTable">The table name of the linking table between the parent and child.</param> /// <param name="childType">The <see cref="T:Type"/> of child.</param> /// <param name="loading">The <see cref="T:Loading"/> behavior to use for this member.</param> /// <param name="cascade"><see cref="T:Cascade"/> behavior of this relationship.</param> public ManyToManyAttribute( string childTable, string linkingTable, Type childType, Mapping.Loading loading, Cascade cascade ) : base() { this.ChildReturnType = childType; this.Name = childTable; this.Linked = true; this.LinkName = linkingTable; this.Loading = loading; this.Cascade = cascade; }
private Rect[] GetFacesInImage(Mat image) { Rect[] faces; lock (cascadeLock) { faces = Cascade.DetectMultiScale(image); } return(faces); }
/// <summary> /// Checks to see if it is possible to move the specified <see cref="Card"/> to the specified <see cref="Cascade"/>. /// </summary> /// <param name="card">The <see cref="Card"/> to check if its possible to move to the specified <see cref="Cascade"/></param> /// <param name="cascade">The <see cref="Cascade"/> that will be holding the specified <see cref="Card"/></param> /// <returns><c>true</c> if the specified <see cref="Card"/> can be moved to the specified <see cref="Stack"/>; otherwise <c>false</c></returns> public virtual bool CanMoveToCascade(Card card, Cascade cascade) { if (!EnforceRules) return true; if (cascade.Count == 0) return true; if (DoCardsLinkInCascade(card, cascade.Last())) return true; return false; }
public void Run() { Console.WriteLine(@"Creating face image..."); SettingData.TotalFrameNum = 0; SettingData.CurrentFrameNum = 0; foreach (var videoName in SettingData.VideoFileNames) { using (var video = new VideoCapture(videoName)) { SettingData.TotalFrameNum += video.FrameCount; } } Cv2.NamedWindow("image", WindowMode.FreeRatio); foreach (var videoName in SettingData.VideoFileNames) { using (var video = VideoCapture.FromFile(videoName)) { var frameNum = 0; while (true) { using (var frame = video.RetrieveMat()) { if (frame.Empty() || IsExitStatus) { if (IsExitStatus) { Console.WriteLine(@"Cancel"); IsExitStatus = false; goto CANCEL; } break; } frameNum++; SettingData.CurrentFrameNum++; //Detecting every 10 frames because the number of images //increases too much when cutting out all frames if (frameNum % SettingData.FrameRateNum == 0) { DetectAndSaveImg(frame); } } } Console.WriteLine(@"End of video"); } } CANCEL: Cv2.DestroyAllWindows(); Cascade.Dispose(); }
public Bag(CodeFileBuilder builder) { _builder = builder; _where = new Where(builder); _orderBy = new OrderBy(builder); _cascade = new Cascade(builder); _fetch = new Fetch(builder); _inverse = new Inverse(builder); _table = new Table(builder); _keyColumn = new KeyColumn(builder); _lazyLoad = new LazyLoad(builder); _cacheBuilder = new CacheBuilder(builder); }
private static Cascade Cleanup(Cascade cascade) { bool hasAll = cascade.Has(Cascade.All) || cascade.Has(AnyButOrphans); if (hasAll && cascade.Has(Cascade.DeleteOrphans)) { return Cascade.All | Cascade.DeleteOrphans; } if (hasAll) { return Cascade.All; } return cascade; }
public void LongPropertyPathAccess_StableBindingSimple() { const string scriptFunctionSourceCode = @" import clr def PropertyPathAccess(cascade) : return cascade.GetChild().GetChild().GetName() "; const int numberChildren = 10; var cascade = new Cascade(numberChildren); var cascadeStableBinding = new CascadeStableBinding(numberChildren); //var cascadeStableBinding = ObjectFactory.Create<CascadeStableBinding> (ParamList.Create (numberChildren)); var cascadeLocalStableBinding = new CascadeLocalStableBinding(numberChildren); var cascadeGetCustomMemberReturnsAttributeProxyFromMap = new CascadeGetCustomMemberReturnsAttributeProxyFromMap(numberChildren); cascadeGetCustomMemberReturnsAttributeProxyFromMap.AddAttributeProxy("GetChild", cascade, _scriptContext); cascadeGetCustomMemberReturnsAttributeProxyFromMap.AddAttributeProxy("GetName", cascade, _scriptContext); var privateScriptEnvironment = ScriptEnvironment.Create(); privateScriptEnvironment.Import(typeof(Cascade).Assembly.GetName().Name, typeof(Cascade).Namespace, typeof(Cascade).Name); var propertyPathAccessScript = new ScriptFunction <Cascade, string> ( _scriptContext, ScriptLanguageType.Python, scriptFunctionSourceCode, privateScriptEnvironment, "PropertyPathAccess" ); privateScriptEnvironment.ImportIifHelperFunctions(); privateScriptEnvironment.SetVariable("GLOBAL_cascade", cascade); var expression = new ExpressionScript <Object> ( _scriptContext, ScriptLanguageType.Python, "GLOBAL_cascade.GetChild().GetChild().GetName()", privateScriptEnvironment ); //var nrLoopsArray = new[] { 1, 1, 10, 100, 1000, 10000, 100000, 1000000 }; var nrLoopsArray = new[] { 1, 1, 10, 100, 1000, 10000 }; ScriptingHelper.ExecuteAndTime("script function", nrLoopsArray, () => propertyPathAccessScript.Execute(cascade)); ScriptingHelper.ExecuteAndTime("script function (stable binding)", nrLoopsArray, () => propertyPathAccessScript.Execute(cascadeStableBinding)); ScriptingHelper.ExecuteAndTime("script function (local stable binding)", nrLoopsArray, () => propertyPathAccessScript.Execute(cascadeLocalStableBinding)); ScriptingHelper.ExecuteAndTime("script function (from map)", nrLoopsArray, () => propertyPathAccessScript.Execute(cascadeGetCustomMemberReturnsAttributeProxyFromMap)); }
/// <summary> /// Gets the child entities which would be affected by the specified cascade. /// </summary> /// <param name="entity">The entity.</param> /// <param name="cascade">The cascade,</param> /// <param name="entities">The entitylist.</param> private void GetChildEntities(Entity entity, Cascade cascade, List <Entity> entities) { if (entities.Contains(entity)) { return; } entities.Add(entity); var entityType = entity.GetType(); var metadata = EntityMetadataResolver.GetEntityMetadata(entityType); foreach (var field in metadata.Fields.Where(x => x.IsComplexFieldType && x.Cascade >= cascade)) { try { var result = ReflectionHelper.GetProperty(entityType, field.ForeignKey).GetValue(entity); if (result != null) { var subEntity = (Entity)result; GetChildEntities(subEntity, cascade, entities); } } catch (TargetInvocationException) { } } foreach (var listField in metadata.ListFields.Where(x => x.Cascade >= cascade)) { var entityCollection = (IEntityCollection)ReflectionHelper.GetProperty(entityType, listField.Name).GetValue(entity); var subEntities = entityCollection.GetCollectionItems(); var removedEntities = entityCollection.GetRemovedCollectionItems(); foreach (var subEntity in subEntities) { if (subEntity != null) { GetChildEntities(subEntity, cascade, entities); } } foreach (var subEntity in removedEntities) { if (subEntity != null) { GetChildEntities(subEntity, cascade, entities); } } } }
public async Task <ActionResult <GetResult> > Get([FromQuery] ChannelRequest request) { if (!await _authManager.HasSitePermissionsAsync(request.SiteId, MenuUtils.SitePermissions.SettingsStyleContent)) { return(Unauthorized()); } var site = await _siteRepository.GetAsync(request.SiteId); if (site == null) { return(NotFound()); } var channel = await _channelRepository.GetAsync(request.ChannelId); var tableName = _channelRepository.GetTableName(site, channel); var relatedIdentities = _tableStyleRepository.GetRelatedIdentities(channel); var styles = await _tableStyleRepository.GetTableStylesAsync(tableName, relatedIdentities); foreach (var style in styles) { style.IsSystem = style.RelatedIdentity != request.ChannelId; } Cascade <int> cascade = null; if (request.ChannelId == request.SiteId) { cascade = await _channelRepository.GetCascadeAsync(site, channel, async summary => { var count = await _contentRepository.GetCountAsync(site, summary); return(new { Count = count }); }); } var inputTypes = ListUtils.GetSelects <InputType>(); return(new GetResult { TableName = tableName, RelatedIdentities = ListUtils.ToString(relatedIdentities), Styles = styles, InputTypes = inputTypes, Channels = cascade }); }
public void LongPropertyPathAccess_DlrVsClr() { const string scriptFunctionSourceCode = @" import clr def PropertyPathAccess(cascade) : if cascade.Child.Child.Child.Child.Child.Child.Child.Child.Child.Name == 'C0' : return cascade.Child.Child.Child.Child.Child.Child.Child.Name return 'FAILED' "; const string expressionScriptSourceCode = "IIf( GLOBAL_cascade.Child.Child.Child.Child.Child.Child.Child.Child.Child.Name == 'C0',GLOBAL_cascade.Child.Child.Child.Child.Child.Child.Child.Name,'FAILED')"; var cascade = new Cascade(10); var privateScriptEnvironment = ScriptEnvironment.Create(); privateScriptEnvironment.ImportIifHelperFunctions(); privateScriptEnvironment.SetVariable("GLOBAL_cascade", cascade); privateScriptEnvironment.Import(typeof(Cascade).Assembly.GetName().Name, typeof(Cascade).Namespace, typeof(Cascade).Name); var propertyPathAccessScript = new ScriptFunction <Cascade, string> ( _scriptContext, ScriptLanguageType.Python, scriptFunctionSourceCode, privateScriptEnvironment, "PropertyPathAccess" ); var propertyPathAccessExpressionScript = new ExpressionScript <string> ( _scriptContext, ScriptLanguageType.Python, expressionScriptSourceCode, privateScriptEnvironment ); var nrLoopsArray = new[] { 1, 1, 10, 100, 1000, 10000, 100000, 1000000 }; //var nrLoopsArray = new[] { 1, 1, 10, 100, 1000, 10000}; ScriptingHelper.ExecuteAndTime("C# method", nrLoopsArray, delegate { if (cascade.Child.Child.Child.Child.Child.Child.Child.Child.Child.Name == "C0") { return(cascade.Child.Child.Child.Child.Child.Child.Child.Name); } return("FAILED"); }); ScriptingHelper.ExecuteAndTime("script function", nrLoopsArray, () => propertyPathAccessScript.Execute(cascade)); ScriptingHelper.ExecuteAndTime("expression script", nrLoopsArray, propertyPathAccessExpressionScript.Execute); }
private static Cascade Cleanup(Cascade cascade) { bool hasAll = cascade.Has(Cascade.All) || cascade.Has(AnyButOrphans); if (hasAll && cascade.Has(Cascade.DeleteOrphans)) { return(Cascade.All | Cascade.DeleteOrphans); } if (hasAll) { return(Cascade.All); } return(cascade); }
public void ProcessCurrentEvents() { //_plugin.PluginEditor.Log("ProcessCurrentEvents"); // a plugin must implement IVstPluginMidiSource or this call will throw an exception. var midiHost = _plugin.Host.GetInstance <IVstMidiProcessor>(); // always expect some hosts not to support this. if (midiHost != null) { var outEvents = new VstEventCollection(); var someCommands = _plugin.Host.GetInstance <IVstHostCommands20>(); var timeInfo = someCommands.GetTimeInfo( VstTimeInfoFlags.PpqPositionValid | VstTimeInfoFlags.BarStartPositionValid | VstTimeInfoFlags.TempoValid); if (CurrentEvents != null) { // NOTE: other types of events could be in the collection! foreach (VstEvent evnt in CurrentEvents) { switch (evnt.EventType) { case VstEventTypes.MidiEvent: var midiEvent = (VstMidiEvent)evnt; midiEvent = Cascade.ProcessEvent(midiEvent, timeInfo); //_plugin.PluginEditor.Log("tempo" + x.Tempo); outEvents.Add(midiEvent); break; default: // non VstMidiEvent outEvents.Add(evnt); break; } } } outEvents.AddRange(Cascade.CreateNotes(timeInfo)); midiHost.Process(outEvents); } // Clear the cache, we've processed the events. CurrentEvents = null; }
public CascadeTests() { var smsRu = new Account() { Type = "sms", Service = "smsru", Login = "******", Balance = 0 }; this._cascade = new Cascade(new List <Validator> { new BalanceValidator(smsRu), new MobilePhoneValidator(new Phone("78123333333")) }); }
protected override Message ReceiveAuthenticatedMessage(AuthenticatedMessage message) { if (message is Bytes) { var bytesMessage = message as Bytes; var bitsAsBytesPayload = bytesMessage.Payload as BitsAsBytes; if (bytesMessage.Demand == Demand.Estimation) { var bobBits = new BitArray(bitsAsBytesPayload.GetBytes().ToList().Skip(8).ToArray()); var aliceBits = new BitArray(DestilationBuffer.GetBytes(bitsAsBytesPayload.Index, bitsAsBytesPayload.Length)); var estimatedQBER = Cascade.EstimateQBER(aliceBits, bobBits); DestilationBuffer.SetEstimatedQBER(estimatedQBER); } if (bytesMessage.Demand == Demand.Confirmation) { } } if (message is AddingKeyAck) { var addingKeyAckMessage = message as AddingKeyAck; if (DoesAckCorrespondsToLastSentKeyIndex(addingKeyAckMessage.Payload as BlockIdAndKeyAllocation)) { _lastReceivedKeyIndexAck = _lastSendKeyIndex; var key = LocalKeyStore.GetKey(); CommonKeyStore.AddNewKey(key, (addingKeyAckMessage.Payload as BlockIdAndKeyAllocation).KeyAllocation); if (!LocalKeyStore.IsEmpty()) { _lastSendKeyIndex += 1; return(PrepareMessageForNewKeyChunk(_lastSendKeyIndex)); } else { return(new NOP()); } } else { throw new UnexpectedMessageException(); } } return(new NOP()); }
public void Apply(Card card) { bool success = false; Cascade aph = (Cascade)card.parentPlaceholder; if (FilterPlaceholders(ArcanaCardRank, card)) { return; } switch (ArcanaCardRank) { case 0: success = aph.ReverseCards(card); aph.ReverseArrows(); aph.behaviour = Behaviour.ReverseAll; break; case 1: success = aph.SortNumericalDescending(card); break; case 2: success = aph.SortByZodiac(card); break; case 3: success = aph.SortBySuit(card); break; case 4: success = aph.RevealOneUp(); break; case 5: success = aph.MoveToBottom(card); break; case 6: success = aph.MoveRowToBottom(card); break; } if (success) { Done(); } }
/// <summary>Creates a new instance of the <see cref="ConfigurationBuilder"/>.</summary> public ConfigurationBuilder(IDefinitionProvider[] definitionProviders, ClassMappingGenerator generator, IWebContext webContext, ConfigurationBuilderParticipator[] participators, DatabaseSection config, ConnectionStringsSection connectionStrings) { this.definitionProviders = definitionProviders; this.generator = generator; this.webContext = webContext; this.participators = participators; if (config == null) config = new DatabaseSection(); TryLocatingHbmResources = config.TryLocatingHbmResources; tablePrefix = config.TablePrefix; batchSize = config.BatchSize; childrenLaziness = config.Children.Laziness; childrenCascade = config.Children.Cascade; cacheRegion = config.CacheRegion; SetupProperties(config, connectionStrings); SetupMappings(config); }
public MyShadowsSettings() { m_shadowCascadeSmallSkipThresholds = new float[] { 1000, 5000, 200, 1000, 1000, 1000 }; m_shadowCascadeFrozen = new bool[6]; m_cascades = new Cascade[8]; // no stabilization, csm resolution 2048, hard shadows: float baseCoef = 5.0f; float cascadePow = 5.0f; float extMult = 2; float snoPart = 758.0f; float skippingSmallObjectsThreshold = 0.0f; for (int i = 0; i < 8; i++) { float cascadeDepth = baseCoef * (float)Math.Pow(cascadePow, i); m_cascades[i].FullCoverageDepth = cascadeDepth; m_cascades[i].ExtendedCoverageDepth = cascadeDepth * extMult; m_cascades[i].ShadowNormalOffset = (cascadeDepth + extMult) / snoPart; m_cascades[i].SkippingSmallObjectThreshold = skippingSmallObjectsThreshold; }; }
public void Cascade(Cascade cascadeStyle) { oneToOne.cascade = (cascadeStyle.Exclude(ByCode.Cascade.DeleteOrphans)).ToCascadeString(); }
public void Cascade(Cascade cascadeStyle) { // not supported by HbmKeyManyToOne }
public bool Equals(Cascade other) { return Equals(other.value, value); }
/// <summary> /// Checks to see if it is possible to move the specified <see cref="Card"/> to the specified <see cref="Cascade"/>. /// </summary> /// <param name="tableaux">The tableaux to try to move to the cascade.</param> /// <param name="cascade">The <see cref="Cascade"/> that will be holding the specified <see cref="Card"/></param> /// <returns><c>true</c> if the specified <see cref="Card"/> can be moved to the specified <see cref="Stack"/>; otherwise <c>false</c></returns> public virtual bool CanMoveToCascade(List<Card> tableaux, Cascade cascade, Game game) { if (!EnforceRules) return true; if (cascade.Count == 0) return true; Card landingCard = cascade.Last(); if (tableaux.Count == 1) { // MOVING ONE CARD if (this.CanMoveToCascade(tableaux.Last(), cascade)) { return true; } else { return false; } } else { // MOVING MULTIPLE CARDS... FIND THE MAXIMUM NUMBER OF MOVES AVAILABLE. int maxMoves = Utility.GetMaximumMovesForGame(game, (cascade.Count == 0)); int level = 1; // WALK BACKWARDS OVER TABLEAUX TRYING EACH CARD AS A LINK TO LANDING CARD. for (int i = (tableaux.Count - 1); i >= 0; i--) { // CHECK FOR THE LINK BETWEEN CURRENT TABLEAUX CARD AND LANDING CARD. if (this.DoCardsLinkInCascade(tableaux[i], landingCard)) { // CARDS LINK, CHECK TO SEE IF WE'VE EXCEEDED OUT MAX NUMBER OF MOVES ALLOWED. if (level > maxMoves) { // MAX NUMBER OF MOVES EXCEEDED, MOVE FAILS return false; } else { // MOVE SUCCESSFUL return true; } } else { // CARDS DO NOT LINK, CONTINUE ONTO THE NEXT TABLEAUX CARD. if (i == 0) { // THIS IS THE LAST CARD IN THE TABLEAUX, MOVE FAILS BECAUSE NO LINKING CARDS FOUND IN STACK. return false; } } level++; } } return false; }
public void Cascade(Cascade cascadeStyle) { manyToOne.cascade = (cascadeStyle & ~ConfOrm.Cascade.DeleteOrphans).ToCascadeString(); }
/// <summary> /// Gets a tableaux from cascade of cards. /// </summary> /// <param name="cascade">The cascade to get tableaux from.</param> /// <param name="rules">The rules to use when determining what makes a tableaux.</param> /// <returns> /// A list of linking cards from the top of a cascade /// </returns> public static List<Card> GetTableauxFromCascade(Cascade cascade, IRules rules) { List<Card> tableaux = new List<Card>(); for (int i = (cascade.Count - 1); i > 0; i--) { tableaux.Add(cascade[i]); if (!rules.DoCardsLinkInCascade(cascade[i], cascade[i - 1])) break; } tableaux.Reverse(); return tableaux; }
/// <summary> /// Initializes a new instance of the <see cref="CascadeGridColumnDefinition"/> class. /// </summary> public CascadeGridColumnDefinition(Cascade cascade, int index) { ColumnIndex = index; Cascade = cascade; }
public static bool Has(this Cascade source, Cascade value) { return (source & value) == value; }
/// <summary> /// Initializes a new instance of the <see cref="CascadeEventArgs"/> class. /// </summary> /// <param name="cascade">The cascade.</param> public CascadeEventArgs(Cascade cascade) { Cascade = cascade; }
public void Cascade(Cascade cascadeStyle) { _manyToOne.cascade = cascadeStyle.ToCascadeString(); }
public static Cascade Include(this Cascade source, Cascade value) { return Cleanup(source | value); }