private RandomGenR() { this.dateModule = new Dates(); this.numberModule = new Numbers(); this.collectionsModule = new Collections(); this.stringsModule = new Strings(); }
public SocketToken(int id, Sinan.Collections.BytesSegment receiveBuffer, Sinan.Collections.BytesSegment sendBuffer, IBufferProcessor processor, Collections.CircularQueue<Collections.BytesSegment> sendPool = null) { m_connectID = id; m_sendPool = sendPool ?? new Collections.CircularQueue<Collections.BytesSegment>(64); m_processor = processor; SocketAsyncEventArgs receiver = new SocketAsyncEventArgs(); receiver.Completed += new EventHandler<SocketAsyncEventArgs>(ReceiveCompleted); receiver.SetBuffer(receiveBuffer.Array, receiveBuffer.Offset, receiveBuffer.Count); SocketAsyncEventArgs sender = new SocketAsyncEventArgs(); sender.Completed += new EventHandler<SocketAsyncEventArgs>(SendCompleted); sender.SetBuffer(sendBuffer.Array, sendBuffer.Offset, sendBuffer.Count); m_receiver = receiver; m_receiveOffset = receiver.Offset; m_receiveMax = receiver.Count; m_sender = sender; m_sendOffset = sender.Offset; m_sendMax = sender.Count; }
void Users_ItemsRemoved(object sender, Collections.CollectionItemsChangedEventArgs<Collections.IndexedItem<User>> e) { foreach (var u in e.Items) { if (u.Value.Id != Guid.Empty) { Content.DeleteUserAsync(u.Value, PluginInfrastructure.ErrorHandling.ShowErrorDialog); } } }
/// <summary> /// Loads the object definitions. /// </summary> /// <param name="configurationModel">The configuration model.</param> public void LoadObjectDefinitions(Collections.Generic.ISet<ConfigurationClass> configurationModel) { foreach (ConfigurationClass configClass in configurationModel) { LoadObjectDefinitionsForConfigurationClass(configClass); } }
private void Content_CheckedItemsChanged(object sender, Collections.CollectionItemsChangedEventArgs<IFilter> e) { if (Content != null) { foreach (IFilter filter in e.Items) { filter.Active = checkedFilterView.Content.ItemChecked(filter); } UpdateFilterInfo(); } }
public override void Initialise(Collections.INamedDataProvider initialisationData) { base.Initialise(initialisationData); initialisationData.TryCopyValue(this, SkyColourName, _skyColour); initialisationData.TryCopyValue(this, GroundColourName, _groundColour); initialisationData.TryCopyValue(this, UpName, _up); }
public override void Initialise(Collections.INamedDataProvider initialisationData) { base.Initialise(initialisationData); initialisationData.TryCopyValue(this, TextureName, _texture); initialisationData.TryCopyValue(this, BrightnessName, _brightness); initialisationData.TryCopyValue(this, GammaCorrectName, _gammaCorrect); }
/// <summary> /// Create a new QualifierAnnotationAutowireCandidateResolver /// for the given qualifier attribute types. /// </summary> /// <param name="qualifierTypes">the qualifier annotations to look for</param> public QualifierAnnotationAutowireCandidateResolver(Collections.Generic.ISet<Type> qualifierTypes) { AssertUtils.ArgumentNotNull(qualifierTypes, "'qualifierTypes' must not be null"); foreach(var type in qualifierTypes) { if (!_qualifierTypes.Contains(type)) _qualifierTypes.Add(type); } }
public Parser(Collections.IList<object> tokens) { this.tokens = tokens; this.index = 0; this.result = this.ParseStmt(); if (this.index != this.tokens.Count) throw new System.Exception("expected EOF"); }
public override void Initialise(Collections.INamedDataProvider initialisationData) { base.Initialise(initialisationData); initialisationData.TryCopyValue(this, ColourName, _colour); initialisationData.TryCopyValue(this, PositionName, _position); initialisationData.TryCopyValue(this, RangeName, _range); initialisationData.TryCopyValue(this, ActiveName, _active); }
public Parser(Collections.IList<object> tokens) { this.tokens = tokens; this.indice = 0; this.resultado = this.ParseStmt(); if (this.indice != this.tokens.Count) throw new System.Exception("se esperaba el final del archivo"); }
public override void Initialise(Collections.INamedDataProvider initialisationData) { base.Initialise(initialisationData); initialisationData.TryCopyValue(this, ColourName, _colour); initialisationData.TryCopyValue(this, DirectionName, _direction); initialisationData.TryCopyValue(this, ShadowResolutionName, _shadowResolution); initialisationData.TryCopyValue(this, ActiveName, _active); }
public MethodParamPair( MethodParamResult method, Interfaces.IEventInput input, Collections.ExitPathGroup _paths) { _result = MethodResult.None; _method = method; _params = input; _exitPaths = _paths; }
protected override void OnItemsChanged(Collections.Specialized.NotifyCollectionChangedEventArgs e) { if (e.Action == Collections.Specialized.NotifyCollectionChangedAction.Remove) { // Don't select itself when its child items got removed. (Default action of base.OnItemsChanged) // The selection should be managed by designer surface. return; } base.OnItemsChanged(e); }
internal static Node<TreeNode> CreateNode(this HierarchyNode<ContentItem> structure, IContentAdapterProvider adapters, Collections.ItemFilter filter) { var adapter = adapters.ResolveAdapter<NodeAdapter>(structure.Current); var children = structure.Children.Select(c => CreateNode(c, adapters, filter)).ToList(); return new Node<TreeNode> { Current = adapter.GetTreeNode(structure.Current), HasChildren = adapter.HasChildren(structure.Current, filter), Expanded = children.Any(), Children = children }; }
/// <summary> /// Checks for emty runner instances. /// </summary> /// <param name="runners">The runners.</param> /// <returns></returns> public static Collections.SelectionList CheckForEmtyRunnerInstances(Collections.SelectionList runners) { if (runners == null) return runners; int removeAt = -1; for (int x = 0; x < runners.Count; x++) { if (runners[x].selectionId <= 0) removeAt = x; } if (removeAt > -1) runners.RemoveAt(removeAt); return runners; }
/// <summary> /// Checks for emty runner instances. /// </summary> /// <param name="market">The market.</param> /// <returns></returns> public static Collections.Market CheckForEmtyRunnerInstances(Collections.Market market) { if (market == null || market.runners == null) return market; int removeAt = -1; for (int x = 0; x < market.runners.Count; x++) { if (market.runners[x].selectionId <= 0) removeAt = x; } if (removeAt > -1) market.runners.RemoveAt(removeAt); market.numberOfRunners = market.runners.Count; return market; }
static void Main(string[] args) { IEnumerable<int> list = new List<int>() { 1, 2, 3, 5 }; foreach (int number in list) { Console.WriteLine(number); } // ... e echivalent cu: using (var enumerator = list.GetEnumerator()) { while (enumerator.MoveNext()) { int number = enumerator.Current; Console.WriteLine(number); } } var collections = new Collections(); foreach (var dwarf in collections.TheSevenDwarves()) { Console.WriteLine("Here comes {0}", dwarf); } var fibonacci = collections.Fibonacci(); var firstFibonacci = collections.FirstTwelve(fibonacci); foreach (var n in firstFibonacci) { Console.WriteLine(n); } Console.WriteLine("------------------------------------------"); var newFibonacci = collections.Fibonacci(); var evenFibonacci = collections.OnlyEven(newFibonacci); var firstEvenFibonacci = collections.FirstTwelve(evenFibonacci); foreach (var n in firstEvenFibonacci) { Console.WriteLine(n); } }
protected override Resource _create( string name, ulong handle, string group, bool isManual, IManualResourceLoader loader, Collections.NameValuePairList createParams ) { string paramSyntax = string.Empty; string paramType = string.Empty; if ( createParams == null || createParams.ContainsKey( "syntax" ) == false || createParams.ContainsKey( "type" ) == false ) { throw new AxiomException( "You must supply 'syntax' and 'type' parameters" ); } else { paramSyntax = createParams[ "syntax" ]; paramType = createParams[ "type" ]; } CreateGpuProgramDelegate iter = null; if ( this._programMap.ContainsKey( paramSyntax ) ) { iter = this._programMap[ paramSyntax ]; } else { // No factory, this is an unsupported syntax code, probably for another rendersystem // Create a basic one, it doesn't matter what it is since it won't be used return new GLES2GpuProgram( this, name, handle, group, isManual, loader ); } GpuProgramType gpt; if ( paramType == "vertex_program" ) { gpt = GpuProgramType.Vertex; } else { gpt = GpuProgramType.Fragment; } return iter( this, name, handle, group, isManual, loader, gpt, paramSyntax ); }
public override IEnumerator <string> GetEnumerator() { return(Collections.UnmodifiableSet(fields.Keys).GetEnumerator()); }
public void GetUpdatedAssignmentGroupResults_NewAssignment_ReturnsAllResultsForNewAssignment() { var section = new Section() { DisplayName = SectionName }; var users = new List <User>(); var assignments = new List <Assignment>(); var submissions = new List <UserQuestionSubmission>(); var oldSnapshot = Collections.CreateList ( CreateSingleAssignmentResults ( "Unit1", 5.0, Collections.CreateList ( CreateAssignmentGroupResult("Unit1", "Last1", "First1", 5.0), CreateAssignmentGroupResult("Unit1", "Last2", "First2", 4.0) ) ) ); var newSnapshot = Collections.CreateList ( CreateSingleAssignmentResults ( "Unit1", 5.0, Collections.CreateList ( CreateAssignmentGroupResult("Unit1", "Last1", "First1", 5.0), CreateAssignmentGroupResult("Unit1", "Last2", "First2", 4.0) ) ), CreateSingleAssignmentResults ( "Unit2", 6.0, Collections.CreateList ( CreateAssignmentGroupResult("Unit2", "Last1", "First1", 6.0), CreateAssignmentGroupResult("Unit2", "Last2", "First2", 2.0) ) ) ); var updatedAssignmentReportGenerator = CreateUpdatedAssignmentReportGenerator ( section, users, assignments, submissions, oldSnapshot, newSnapshot ); var results = updatedAssignmentReportGenerator.GetUpdatedAssignmentGroupResults ( assignments, users, section, GradebookName, DateLastTransferred, submissions ); Assert.Equal(1, results.AssignmentResults.Count); var sectionAssignmentResults = results.AssignmentResults[0]; Assert.Equal(SectionName, sectionAssignmentResults.SectionName); Assert.Equal("Unit2", sectionAssignmentResults.AssignmentGroupName); Assert.Equal(6.0, sectionAssignmentResults.Points); Assert.Equal(2, sectionAssignmentResults.AssignmentGroupResults.Count); { var assignmentGroupResult = sectionAssignmentResults.AssignmentGroupResults[0]; Assert.Equal("Unit2", assignmentGroupResult.AssignmentGroupName); Assert.Equal("Last1", assignmentGroupResult.LastName); Assert.Equal("First1", assignmentGroupResult.FirstName); Assert.Equal(6.0, assignmentGroupResult.Score); } { var assignmentGroupResult = sectionAssignmentResults.AssignmentGroupResults[1]; Assert.Equal("Unit2", assignmentGroupResult.AssignmentGroupName); Assert.Equal("Last2", assignmentGroupResult.LastName); Assert.Equal("First2", assignmentGroupResult.FirstName); Assert.Equal(2.0, assignmentGroupResult.Score); } }
public IDictionary <string, object> metaData() { return(Collections.emptyMap()); }
public List <SortPredicate> getSortPredicates() { return(Collections.unmodifiableList(_sortPredicates)); }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test public void testUpdateEventTrigger() public virtual void testUpdateEventTrigger() { // given string newMessageName = "newMessage"; ProcessDefinition sourceProcessDefinition = migrationRule.deployAndGetDefinition(ProcessModels.ONE_RECEIVE_TASK_PROCESS); ProcessDefinition targetProcessDefinition = migrationRule.deployAndGetDefinition(modify(ProcessModels.ONE_RECEIVE_TASK_PROCESS).renameMessage("Message", newMessageName)); ProcessInstance processInstance = runtimeService.startProcessInstanceById(sourceProcessDefinition.Id); MigrationPlan migrationPlan = runtimeService.createMigrationPlan(sourceProcessDefinition.Id, targetProcessDefinition.Id).mapEqualActivities().updateEventTriggers().build(); Batch batch = runtimeService.newMigration(migrationPlan).processInstanceIds(Collections.singletonList(processInstance.Id)).executeAsync(); helper.executeSeedJob(batch); // when helper.executeJobs(batch); // then the message event subscription's event name was changed EventSubscription eventSubscription = runtimeService.createEventSubscriptionQuery().singleResult(); assertEquals(newMessageName, eventSubscription.EventName); }
private void RunAssertionNestedDotMethod(bool grouped, bool soda) { var eplDeclare = "create table varagg (" + (grouped ? "key string primary key, " : "") + "windowSupportBean window(*) @type('SupportBean'))"; SupportModelHelper.CreateByCompileOrParse(_epService, soda, eplDeclare); var eplInto = "into table varagg " + "select window(*) as windowSupportBean from SupportBean.win:length(2)" + (grouped ? " group by TheString" : ""); SupportModelHelper.CreateByCompileOrParse(_epService, soda, eplInto); var key = grouped ? "[\"E1\"]" : ""; var eplSelect = "select " + "varagg" + key + ".windowSupportBean.last(*).IntPrimitive as c0, " + "varagg" + key + ".windowSupportBean.window(*).countOf() as c1, " + "varagg" + key + ".windowSupportBean.window(IntPrimitive).take(1) as c2" + " from SupportBean_S0"; EPStatement stmtSelect = SupportModelHelper.CreateByCompileOrParse(_epService, soda, eplSelect); stmtSelect.AddListener(_listener); var expectedAggType = new object[][] { new object[] { "c0", typeof(int?) }, new object[] { "c1", typeof(int) }, new object[] { "c2", typeof(ICollection <object>) } }; EventTypeAssertionUtil.AssertEventTypeProperties(expectedAggType, stmtSelect.EventType, EventTypeAssertionEnum.NAME, EventTypeAssertionEnum.TYPE); var fields = "c0,c1,c2".Split(','); MakeSendBean("E1", 10, 0); _epService.EPRuntime.SendEvent(new SupportBean_S0(0)); EPAssertionUtil.AssertProps(_listener.AssertOneGetNewAndReset(), fields, new object[] { 10, 1, Collections.SingletonList(10) }); MakeSendBean("E1", 20, 0); _epService.EPRuntime.SendEvent(new SupportBean_S0(0)); EPAssertionUtil.AssertProps(_listener.AssertOneGetNewAndReset(), fields, new object[] { 20, 2, Collections.SingletonList(10) }); MakeSendBean("E1", 30, 0); _epService.EPRuntime.SendEvent(new SupportBean_S0(0)); EPAssertionUtil.AssertProps(_listener.AssertOneGetNewAndReset(), fields, new object[] { 30, 2, Collections.SingletonList(20) }); _epService.EPAdministrator.DestroyAllStatements(); _epService.EPAdministrator.Configuration.RemoveEventType("table_varagg__internal", false); _epService.EPAdministrator.Configuration.RemoveEventType("table_varagg__public", false); }
// 统计集合 int Count(List<ListViewItem> items, ref Collections cols, out string strError) { strError = ""; foreach (ListViewItem item in items) { string strBorrower = ListViewUtil.GetItemText(item, COLUMN_BORROWER); int nImageIndex = item.ImageIndex; if (nImageIndex == TYPE_ERROR) { cols.Error.Add(item); continue; } else if (nImageIndex == TYPE_VERIFIED) { cols.Scaned.Add(item); cols.OnShelf.Add(item); } else if (nImageIndex == TYPE_NOTRETURN) { cols.Scaned.Add(item); cols.OnShelf.Add(item); cols.OnShelfBorrowed.Add(item); } else if (nImageIndex == TYPE_NORMAL) { if (string.IsNullOrEmpty(strBorrower) == false) cols.Borrowed.Add(item); else cols.Lost.Add(item); } if (string.IsNullOrEmpty(strBorrower) == false) cols.DataBorrowed.Add(item); else cols.DataOnShelf.Add(item); } return 0; }
public virtual void testProcessVariableValueLessThan() { runtimeService.startProcessInstanceByKey("oneTaskProcess", Collections.singletonMap <string, object>("requestNumber", 123)); assertEquals(1, historyService.createHistoricTaskInstanceQuery().processVariableValueLessThan("requestNumber", 124).count()); }
public void InitializeSuperfluosLayersQuestion(Collections.SelectableListNodeList list) { GuiHelper.Initialize(_cbSuperfluousLayersAction, list); }
//-------------------------------------------------------------- /// <inheritdoc/> internal override void Flatten(Collections.ArrayList<Vector3F> vertices, Collections.ArrayList<int> strokeIndices, Collections.ArrayList<int> fillIndices) { _arcSegment.IsLargeArc = true; _arcSegment.Point1 = new Vector2F(RadiusX, 0); _arcSegment.Point2 = _arcSegment.Point1; _arcSegment.Radius = new Vector2F(RadiusX, RadiusY); _arcSegment.RotationAngle = 0; _arcSegment.SweepClockwise = false; var tempVertices = ResourcePools<Vector2F>.Lists.Obtain(); _arcSegment.Flatten(tempVertices, MaxNumberOfIterations, Tolerance); int numberOfVertices = tempVertices.Count; if (numberOfVertices < 2) return; int startIndex = vertices.Count; // Add 3D vertices. We skip the duplicated vertices. for (int i = 0; i < numberOfVertices; i += 2) vertices.Add(new Vector3F(tempVertices[i].X, tempVertices[i].Y, 0)); // Add stroke indices. for (int i = 0; i < numberOfVertices - 1; i++) strokeIndices.Add(startIndex + (i + 1) / 2); // Closing stroke: strokeIndices.Add(startIndex); if (IsFilled) { // Add a center vertex. var centerIndex = vertices.Count; vertices.Add(new Vector3F(0, 0, 0)); // Add one triangle per circle segment. for (int i = 0; i < numberOfVertices / 2 - 1; i++) { fillIndices.Add(centerIndex); fillIndices.Add(startIndex + i + 1); fillIndices.Add(startIndex + i); } // Last triangle: fillIndices.Add(centerIndex); fillIndices.Add(startIndex); fillIndices.Add(centerIndex - 1); } ResourcePools<Vector2F>.Lists.Recycle(tempVertices); }
public CodegenClass Forge( bool includeDebugSymbols, bool fireAndForget) { Supplier<string> debugInformationProvider = () => { var writer = new StringWriter(); _raw.AppendCodeDebugInfo(writer); writer.Write(" output-processor "); writer.Write(_spec.GetType().FullName); return writer.ToString(); }; try { IList<CodegenInnerClass> innerClasses = new List<CodegenInnerClass>(); // build ctor IList<CodegenTypedParam> ctorParms = new List<CodegenTypedParam>(); ctorParms.Add( new CodegenTypedParam( typeof(EPStatementInitServices), EPStatementInitServicesConstants.REF.Ref, false)); ctorParms.Add( new CodegenTypedParam( _namespaceScope.FieldsClassName, null, "statementFields", true, false)); var providerCtor = new CodegenCtor( typeof(StmtClassForgeableOPVFactoryProvider), ClassName, includeDebugSymbols, ctorParms); var classScope = new CodegenClassScope(includeDebugSymbols, _namespaceScope, ClassName); var providerExplicitMembers = new List<CodegenTypedParam>(); providerExplicitMembers.Add( new CodegenTypedParam(typeof(StatementResultService), MEMBERNAME_STATEMENTRESULTSVC)); providerExplicitMembers.Add( new CodegenTypedParam(typeof(OutputProcessViewFactory), MEMBERNAME_OPVFACTORY)); if (_spec.IsCodeGenerated) { // make factory and view both, assign to member MakeOPVFactory(classScope, innerClasses, providerExplicitMembers, providerCtor, ClassName); MakeOPV( classScope, innerClasses, Collections.GetEmptyList<CodegenTypedParam>(), providerCtor, ClassName, _spec, _numStreams); } else { // build factory from existing classes var symbols = new SAIFFInitializeSymbol(); var init = providerCtor .MakeChildWithScope(typeof(OutputProcessViewFactory), GetType(), symbols, classScope) .AddParam( typeof(EPStatementInitServices), EPStatementInitServicesConstants.REF.Ref); _spec.ProvideCodegen(init, symbols, classScope); providerCtor.Block.AssignRef( MEMBERNAME_OPVFACTORY, LocalMethod(init, EPStatementInitServicesConstants.REF)); } // make get-factory method var factoryMethodGetter = CodegenProperty.MakePropertyNode( typeof(OutputProcessViewFactory), GetType(), CodegenSymbolProviderEmpty.INSTANCE, classScope); factoryMethodGetter.GetterBlock.BlockReturn(Ref(MEMBERNAME_OPVFACTORY)); var properties = new CodegenClassProperties(); var methods = new CodegenClassMethods(); CodegenStackGenerator.RecursiveBuildStack( providerCtor, "ctor", methods, properties); CodegenStackGenerator.RecursiveBuildStack( factoryMethodGetter, "OutputProcessViewFactory", methods, properties); // render and compile return new CodegenClass( CodegenClassType.OUTPUTPROCESSVIEWFACTORYPROVIDER, typeof(OutputProcessViewFactoryProvider), ClassName, classScope, providerExplicitMembers, providerCtor, methods, properties, innerClasses); } catch (Exception t) { throw new EPException( "Fatal exception during code-generation for " + debugInformationProvider.Invoke() + " : " + t.Message, t); } }
private static void MakeOPV( CodegenClassScope classScope, IList<CodegenInnerClass> innerClasses, IList<CodegenTypedParam> factoryExplicitMembers, CodegenCtor factoryCtor, string classNameParent, OutputProcessViewFactoryForge forge, int numStreams) { IList<CodegenTypedParam> ctorParams = new List<CodegenTypedParam>(); ctorParams.Add(new CodegenTypedParam(classNameParent, "o")); ctorParams.Add(new CodegenTypedParam(typeof(ResultSetProcessor), NAME_RESULTSETPROCESSOR)); ctorParams.Add(new CodegenTypedParam(typeof(AgentInstanceContext), NAME_AGENTINSTANCECONTEXT)); // make ctor code var serviceCtor = new CodegenCtor(typeof(StmtClassForgeableOPVFactoryProvider), classScope, ctorParams); // Get-Result-Type Method var eventTypeGetter = CodegenProperty .MakePropertyNode(typeof(EventType), forge.GetType(), CodegenSymbolProviderEmpty.INSTANCE, classScope) .WithOverride(); eventTypeGetter.GetterBlock.BlockReturn(ExprDotName(Ref(NAME_RESULTSETPROCESSOR), "ResultEventType")); // Process-View-Result Method var updateMethod = CodegenMethod .MakeMethod(typeof(void), forge.GetType(), CodegenSymbolProviderEmpty.INSTANCE, classScope) .WithOverride() .AddParam(typeof(EventBean[]), NAME_NEWDATA) .AddParam(typeof(EventBean[]), NAME_OLDDATA); if (numStreams == 1) { forge.UpdateCodegen(updateMethod, classScope); } else { updateMethod.Block.MethodThrowUnsupported(); } // Process-Join-Result Method var processMethod = CodegenMethod .MakeMethod(typeof(void), forge.GetType(), CodegenSymbolProviderEmpty.INSTANCE, classScope) .WithOverride() .AddParam(typeof(ISet<MultiKeyArrayOfKeys<EventBean>>), NAME_NEWDATA) .AddParam(typeof(ISet<MultiKeyArrayOfKeys<EventBean>>), NAME_OLDDATA) .AddParam( typeof(ExprEvaluatorContext), "notApplicable"); if (numStreams == 1) { processMethod.Block.MethodThrowUnsupported(); } else { forge.ProcessCodegen(processMethod, classScope); } // Stop-Method (generates last as other methods may allocate members) var enumeratorMethod = CodegenMethod .MakeMethod( typeof(IEnumerator<EventBean>), forge.GetType(), CodegenSymbolProviderEmpty.INSTANCE, classScope) .WithOverride(); forge.EnumeratorCodegen(enumeratorMethod, classScope); // NumChangesetRows (always zero for generated code) var numChangesetRowsProp = CodegenProperty .MakePropertyNode(typeof(int), forge.GetType(), CodegenSymbolProviderEmpty.INSTANCE, classScope) .WithOverride(); numChangesetRowsProp.GetterBlock.BlockReturn(Constant(0)); // OptionalOutputCondition (always null for generated code) var optionalOutputConditionProp = CodegenProperty .MakePropertyNode(typeof(OutputCondition), forge.GetType(), CodegenSymbolProviderEmpty.INSTANCE, classScope) .WithOverride(); optionalOutputConditionProp.GetterBlock.BlockReturn(ConstantNull()); // Stop-Method (no action for generated code) CodegenMethod stopMethod = CodegenMethod .MakeMethod(typeof(void), forge.GetType(), CodegenSymbolProviderEmpty.INSTANCE, classScope) .WithOverride() .AddParam(typeof(AgentInstanceStopServices), "svc"); // Terminate-Method (no action for generated code) CodegenMethod terminatedMethod = CodegenMethod .MakeMethod(typeof(void), forge.GetType(), CodegenSymbolProviderEmpty.INSTANCE, classScope) .WithOverride(); var innerProperties = new CodegenClassProperties(); var innerMethods = new CodegenClassMethods(); CodegenStackGenerator.RecursiveBuildStack( eventTypeGetter, "EventType", innerMethods, innerProperties); CodegenStackGenerator.RecursiveBuildStack( updateMethod, "Update", innerMethods, innerProperties); CodegenStackGenerator.RecursiveBuildStack( processMethod, "Process", innerMethods, innerProperties); CodegenStackGenerator.RecursiveBuildStack( enumeratorMethod, "GetEnumerator", innerMethods, innerProperties); CodegenStackGenerator.RecursiveBuildStack( numChangesetRowsProp, "NumChangesetRows", innerMethods, innerProperties); CodegenStackGenerator.RecursiveBuildStack( optionalOutputConditionProp, "OptionalOutputCondition", innerMethods, innerProperties); CodegenStackGenerator.RecursiveBuildStack( stopMethod, "Stop", innerMethods, innerProperties); CodegenStackGenerator.RecursiveBuildStack( terminatedMethod, "Terminated", innerMethods, innerProperties); var innerClass = new CodegenInnerClass( CLASSNAME_OUTPUTPROCESSVIEW, typeof(OutputProcessView), serviceCtor, Collections.GetEmptyList<CodegenTypedParam>(), innerMethods, innerProperties); innerClasses.Add(innerClass); }
/// <summary>Configure the generator to compute reverse blame (history of deletes).</summary> /// <remarks> /// Configure the generator to compute reverse blame (history of deletes). /// <p> /// This method is expensive as it immediately runs a RevWalk over the /// history spanning the expression /// <code>start..end</code> /// (end being more recent /// than start) and then performs the equivalent operation as /// <see cref="Push(string, NGit.AnyObjectId)">Push(string, NGit.AnyObjectId)</see> /// to begin blame traversal from the /// commit named by /// <code>start</code> /// walking forwards through history until /// <code>end</code> /// blaming line deletions. /// <p> /// A reverse blame may produce multiple sources for the same result line, /// each of these is a descendant commit that removed the line, typically /// this occurs when the same deletion appears in multiple side branches such /// as due to a cherry-pick. Applications relying on reverse should use /// <see cref="BlameResult">BlameResult</see> /// as it filters these duplicate sources and only /// remembers the first (oldest) deletion. /// </remarks> /// <param name="start"> /// oldest commit to traverse from. The result file will be loaded /// from this commit's tree. /// </param> /// <param name="end"> /// most recent commit to stop traversal at. Usually an active /// branch tip, tag, or HEAD. /// </param> /// <returns> /// /// <code>this</code> /// </returns> /// <exception cref="System.IO.IOException">the repository cannot be read.</exception> public virtual NGit.Blame.BlameGenerator Reverse(AnyObjectId start, AnyObjectId end ) { return(Reverse(start, Collections.Singleton(end.ToObjectId()))); }
public void GetUpdatedAssignmentGroupResults_NoNewSubmissions_ReturnsNoResults() { var section = new Section() { DisplayName = SectionName }; var users = new List <User>(); var assignments = new List <Assignment>(); var submissions = new List <UserQuestionSubmission>(); var oldSnapshot = Collections.CreateList ( CreateSingleAssignmentResults ( "Unit1", 5.0, Collections.CreateList ( CreateAssignmentGroupResult("Unit1", "Last1", "First1", 5.0) ) ), CreateSingleAssignmentResults ( "Unit2", 6.0, Collections.CreateList ( CreateAssignmentGroupResult("Unit2", "Last1", "First1", 6.0) ) ) ); var newSnapshot = Collections.CreateList ( CreateSingleAssignmentResults ( "Unit1", 5.0, Collections.CreateList ( CreateAssignmentGroupResult("Unit1", "Last1", "First1", 5.0) ) ), CreateSingleAssignmentResults ( "Unit2", 6.0, Collections.CreateList ( CreateAssignmentGroupResult("Unit2", "Last1", "First1", 6.0) ) ) ); var updatedAssignmentReportGenerator = CreateUpdatedAssignmentReportGenerator ( section, users, assignments, submissions, oldSnapshot, newSnapshot ); var results = updatedAssignmentReportGenerator.GetUpdatedAssignmentGroupResults ( assignments, users, section, GradebookName, DateLastTransferred, submissions ); Assert.Equal(0, results.AssignmentResults.Count); }
public override Graphics.RenderWindow NewWindow( string name, int width, int height, bool fullScreen, Collections.NamedParameterList miscParams = null ) { IPhoneWindow window = new IPhoneWindow(); window.Create( name, width, height, fullScreen, miscParams ); return window; }
public virtual void testSkipTaskListenerInvocation() { ProcessInstance processInstance = runtimeService.startProcessInstanceByKey("taskListenerProcess", "brum", Collections.singletonMap <string, object> ("listener", new RecorderTaskListener())); string processInstanceId = processInstance.Id; RecorderTaskListener.clear(); // when I start an activity with "skip listeners" setting Batch modificationBatch = runtimeService.createProcessInstanceModification(processInstanceId).startBeforeActivity("task").executeAsync(true, false); assertNotNull(modificationBatch); executeSeedAndBatchJobs(modificationBatch); // then no listeners are invoked assertTrue(RecorderTaskListener.RecordedEvents.Count == 0); // when I cancel an activity with "skip listeners" setting ActivityInstance activityInstanceTree = runtimeService.getActivityInstance(processInstanceId); Batch batch = runtimeService.createProcessInstanceModification(processInstance.Id).cancelActivityInstance(getChildInstanceForActivity(activityInstanceTree, "task").Id).executeAsync(true, false); assertNotNull(batch); executeSeedAndBatchJobs(batch); // then no listeners are invoked assertTrue(RecorderTaskListener.RecordedEvents.Count == 0); }
private static void Postfix(StandardLevelDetailView __instance, ref IDifficultyBeatmap ____selectedDifficultyBeatmap, ref Button ____actionButton, ref Button ____practiceButton, ref BeatmapDifficultySegmentedControlController ____beatmapDifficultySegmentedControlController, ref BeatmapCharacteristicSegmentedControlController ____beatmapCharacteristicSegmentedControlController) { var firstSelection = false; var level = ____selectedDifficultyBeatmap.level is CustomBeatmapLevel ? ____selectedDifficultyBeatmap.level as CustomPreviewBeatmapLevel : null; if (level != lastLevel) { firstSelection = true; lastLevel = level; } ____actionButton.interactable = true; ____practiceButton.interactable = true; RequirementsUI.instance.ButtonGlowColor = false; RequirementsUI.instance.ButtonInteractable = false; if (level == null) { return; } var songData = Collections.RetrieveExtraSongData(Hashing.GetCustomLevelHash(level), level.customLevelPath); if (songData == null) { RequirementsUI.instance.ButtonGlowColor = false; RequirementsUI.instance.ButtonInteractable = false; return; } var wipFolderSong = false; var selectedDiff = ____selectedDifficultyBeatmap; var diffData = Collections.RetrieveDifficultyData(selectedDiff); if (diffData != null) { //If no additional information is present if (!diffData.additionalDifficultyData._requirements.Any() && !diffData.additionalDifficultyData._suggestions.Any() && !diffData.additionalDifficultyData._warnings.Any() && !diffData.additionalDifficultyData._information.Any() && !songData.contributors.Any()) { RequirementsUI.instance.ButtonGlowColor = false; RequirementsUI.instance.ButtonInteractable = false; } else if (!diffData.additionalDifficultyData._warnings.Any()) { RequirementsUI.instance.ButtonGlowColor = true; RequirementsUI.instance.ButtonInteractable = true; } else if (diffData.additionalDifficultyData._warnings.Any()) { RequirementsUI.instance.ButtonGlowColor = true; RequirementsUI.instance.ButtonInteractable = true; if (diffData.additionalDifficultyData._warnings.Contains("WIP")) { ____actionButton.interactable = false; } } } if (level.levelID.EndsWith(" WIP")) { RequirementsUI.instance.ButtonGlowColor = true; RequirementsUI.instance.ButtonInteractable = true; ____actionButton.interactable = false; wipFolderSong = true; } if (diffData != null) { foreach (var requirement in diffData.additionalDifficultyData._requirements) { if (!Collections.capabilities.Contains(requirement)) { ____actionButton.interactable = false; ____practiceButton.interactable = false; RequirementsUI.instance.ButtonGlowColor = true; RequirementsUI.instance.ButtonInteractable = true; } } } if (selectedDiff.parentDifficultyBeatmapSet.beatmapCharacteristic.serializedName == "MissingCharacteristic") { ____actionButton.interactable = false; ____practiceButton.interactable = false; RequirementsUI.instance.ButtonGlowColor = true; RequirementsUI.instance.ButtonInteractable = true; } RequirementsUI.instance.level = level; RequirementsUI.instance.songData = songData; RequirementsUI.instance.diffData = diffData; RequirementsUI.instance.wipFolder = wipFolderSong; //Difficulty Label Handling LevelLabels.Clear(); string currentCharacteristic = string.Empty; foreach (Data.ExtraSongData.DifficultyData diffLevel in songData._difficulties) { var difficulty = diffLevel._difficulty; string characteristic = diffLevel._beatmapCharacteristicName; if (characteristic == selectedDiff.parentDifficultyBeatmapSet.beatmapCharacteristic.serializedName) { currentCharacteristic = characteristic; } if (!LevelLabels.ContainsKey(characteristic)) { LevelLabels.Add(characteristic, new OverrideLabels()); } var charLabels = LevelLabels[characteristic]; if (!string.IsNullOrWhiteSpace(diffLevel._difficultyLabel)) { switch (difficulty) { case BeatmapDifficulty.Easy: charLabels.EasyOverride = diffLevel._difficultyLabel; break; case BeatmapDifficulty.Normal: charLabels.NormalOverride = diffLevel._difficultyLabel; break; case BeatmapDifficulty.Hard: charLabels.HardOverride = diffLevel._difficultyLabel; break; case BeatmapDifficulty.Expert: charLabels.ExpertOverride = diffLevel._difficultyLabel; break; case BeatmapDifficulty.ExpertPlus: charLabels.ExpertPlusOverride = diffLevel._difficultyLabel; break; } } } if (!string.IsNullOrWhiteSpace(currentCharacteristic)) { SetCurrentLabels(LevelLabels[currentCharacteristic]); } else { ClearOverrideLabels(); } ____beatmapDifficultySegmentedControlController.SetData(____selectedDifficultyBeatmap.parentDifficultyBeatmapSet.difficultyBeatmaps, ____beatmapDifficultySegmentedControlController.selectedDifficulty); ClearOverrideLabels(); // TODO: Check if this whole if block is still needed if (songData._defaultCharacteristic != null && firstSelection) { if (____beatmapCharacteristicSegmentedControlController.selectedBeatmapCharacteristic.serializedName != songData._defaultCharacteristic) { var chars = ____beatmapCharacteristicSegmentedControlController.GetField <List <BeatmapCharacteristicSO>, BeatmapCharacteristicSegmentedControlController>("_beatmapCharacteristics"); var index = 0; foreach (var characteristic in chars) { if (songData._defaultCharacteristic == characteristic.serializedName) { break; } index++; } if (index != chars.Count) { ____beatmapCharacteristicSegmentedControlController.GetField <HMUI.IconSegmentedControl, BeatmapCharacteristicSegmentedControlController>("_segmentedControl") .SelectCellWithNumber(index); ____beatmapCharacteristicSegmentedControlController.HandleDifficultySegmentedControlDidSelectCell( ____beatmapCharacteristicSegmentedControlController.GetField <HMUI.IconSegmentedControl, BeatmapCharacteristicSegmentedControlController>("_segmentedControl"), index); } } } }
public async Task <IActionResult> CreateAndConnect(string tablename, int tableid, int infotype, string currentpath, [Bind("Id,Firstnameauhor1,Lastnameauhor1,Firstnameauhor2,Lastnameauhor2,Firstnameauhor3,Lastnameauhor3,Furtherauthors,Publisher,Title,Location,Edition,Publicationdate,Pages")] Collections collections) { int id = new int(); String[] url = new String[4]; if (ModelState.IsValid) { _context.Add(collections); await _context.SaveChangesAsync(); List <Collections> allentries = new List <Collections>(); allentries = await _context.Collections.ToListAsync(); foreach (Collections item in allentries) { if (item == collections) { id = collections.Id; } } var relation = new InfoSourcesInRelation { Tablename = tablename, Tableid = tableid, Infotype = infotype, Infosourceid = id }; _context.Add(relation); await _context.SaveChangesAsync(); url = currentpath.Split('/'); return(RedirectToAction(url[3], url[2], new { id = url[4] })); // return RedirectToAction("CreateAndConnect", "InfoSourcesInRelations", new { tablename = tablename, tableid = tableid, infotype = infotype, infosourceid = id, currentpath = currentpath }); } return(View(collections)); }
public void TestIt() { var NOT_EXISTS = ValueWithExistsFlag.MultipleNotExists(6); // Bean SupportBeanComplexProps beanOne = SupportBeanComplexProps.MakeDefaultBean(); string n1_v = beanOne.Nested.NestedValue; string n1_n_v = beanOne.Nested.NestedNested.NestedNestedValue; SupportBeanComplexProps beanTwo = SupportBeanComplexProps.MakeDefaultBean(); beanTwo.Nested.NestedValue = "nested1"; beanTwo.Nested.NestedNested.SetNestedNestedValue("nested2"); var beanTests = new Pair <SupportBeanDynRoot, ValueWithExistsFlag[]>[] { new Pair <SupportBeanDynRoot, ValueWithExistsFlag[]>(new SupportBeanDynRoot(beanOne), ValueWithExistsFlag.AllExist(n1_v, n1_v, n1_n_v, n1_n_v, n1_n_v, n1_n_v)), new Pair <SupportBeanDynRoot, ValueWithExistsFlag[]>(new SupportBeanDynRoot(beanTwo), ValueWithExistsFlag.AllExist("nested1", "nested1", "nested2", "nested2", "nested2", "nested2")), new Pair <SupportBeanDynRoot, ValueWithExistsFlag[]>(new SupportBeanDynRoot("abc"), NOT_EXISTS) }; RunAssertion(BEAN_TYPENAME, SupportEventInfra.FBEAN, null, beanTests, typeof(object)); // Map IDictionary <string, object> mapOneL2 = new Dictionary <string, object>(); mapOneL2.Put("nestedNestedValue", 101); IDictionary <string, object> mapOneL1 = new Dictionary <string, object>(); mapOneL1.Put("nestedNested", mapOneL2); mapOneL1.Put("nestedValue", 100); IDictionary <string, object> mapOneL0 = new Dictionary <string, object>(); mapOneL0.Put("nested", mapOneL1); var mapOne = Collections.SingletonDataMap("item", mapOneL0); var mapTests = new Pair <IDictionary <string, object>, ValueWithExistsFlag[]>[] { new Pair <IDictionary <string, object>, ValueWithExistsFlag[]>(mapOne, ValueWithExistsFlag.AllExist(100, 100, 101, 101, 101, 101)), new Pair <IDictionary <string, object>, ValueWithExistsFlag[]>(Collections.EmptyDataMap, NOT_EXISTS), }; RunAssertion(SupportEventInfra.MAP_TYPENAME, SupportEventInfra.FMAP, null, mapTests, typeof(object)); // Object-Array var oaOneL2 = new object[] { 101 }; var oaOneL1 = new object[] { oaOneL2, 100 }; var oaOneL0 = new object[] { oaOneL1 }; var oaOne = new object[] { oaOneL0 }; var oaTests = new Pair <object[], ValueWithExistsFlag[]>[] { new Pair <object[], ValueWithExistsFlag[]>(oaOne, ValueWithExistsFlag.AllExist(100, 100, 101, 101, 101, 101)), new Pair <object[], ValueWithExistsFlag[]>(new object[] { null }, NOT_EXISTS), }; RunAssertion(SupportEventInfra.OA_TYPENAME, SupportEventInfra.FOA, null, oaTests, typeof(object)); // XML var xmlTests = new Pair <string, ValueWithExistsFlag[]>[] { new Pair <string, ValueWithExistsFlag[]>("<item>\n" + "\t<nested nestedValue=\"100\">\n" + "\t\t<nestedNested nestedNestedValue=\"101\">\n" + "\t\t</nestedNested>\n" + "\t</nested>\n" + "</item>\n", ValueWithExistsFlag.AllExist("100", "100", "101", "101", "101", "101")), new Pair <string, ValueWithExistsFlag[]>("<item/>", NOT_EXISTS), }; RunAssertion(SupportEventInfra.XML_TYPENAME, SupportEventInfra.FXML, SupportEventInfra.XML_TO_VALUE, xmlTests, typeof(XmlNode)); // Avro var schema = GetAvroSchema(); var nestedSchema = AvroSchemaUtil.FindUnionRecordSchemaSingle( schema.GetField("item").Schema.GetField("nested").Schema).AsRecordSchema(); var nestedNestedSchema = AvroSchemaUtil.FindUnionRecordSchemaSingle( nestedSchema.GetField("nestedNested").Schema).AsRecordSchema(); var nestedNestedDatum = new GenericRecord(nestedNestedSchema); nestedNestedDatum.Put("nestedNestedValue", 101); var nestedDatum = new GenericRecord(nestedSchema); nestedDatum.Put("nestedValue", 100); nestedDatum.Put("nestedNested", nestedNestedDatum); var emptyDatum = new GenericRecord(SchemaBuilder.Record(SupportEventInfra.AVRO_TYPENAME)); var avroTests = new Pair <object, ValueWithExistsFlag[]>[] { new Pair <object, ValueWithExistsFlag[]>(nestedDatum, ValueWithExistsFlag.AllExist(100, 100, 101, 101, 101, 101)), new Pair <object, ValueWithExistsFlag[]>(emptyDatum, NOT_EXISTS), new Pair <object, ValueWithExistsFlag[]>(null, NOT_EXISTS) }; RunAssertion(SupportEventInfra.AVRO_TYPENAME, FAVRO, null, avroTests, typeof(object)); }
private FilterSpecCompiled Compile(FilterStreamSpecRaw raw) { var compiled = (FilterStreamSpecCompiled)raw.Compile(SupportStatementContextFactory.MakeContext(_container), new HashSet <String>(), false, Collections.GetEmptyList <int>(), false, false, false, null); return(compiled.FilterSpec); }
/// <summary> /// Seals the <see cref="Index.SegmentInfo"/> for the new flushed segment and persists /// the deleted documents <see cref="IMutableBits"/>. /// </summary> internal virtual void SealFlushedSegment(FlushedSegment flushedSegment) { Debug.Assert(flushedSegment != null); SegmentCommitInfo newSegment = flushedSegment.segmentInfo; IndexWriter.SetDiagnostics(newSegment.Info, IndexWriter.SOURCE_FLUSH); IOContext context = new IOContext(new FlushInfo(newSegment.Info.DocCount, newSegment.GetSizeInBytes())); bool success = false; try { if (indexWriterConfig.UseCompoundFile) { Collections.AddAll(filesToDelete, IndexWriter.CreateCompoundFile(infoStream, directory, CheckAbort.NONE, newSegment.Info, context)); newSegment.Info.UseCompoundFile = true; } // Have codec write SegmentInfo. Must do this after // creating CFS so that 1) .si isn't slurped into CFS, // and 2) .si reflects useCompoundFile=true change // above: codec.SegmentInfoFormat.SegmentInfoWriter.Write(directory, newSegment.Info, flushedSegment.fieldInfos, context); // TODO: ideally we would freeze newSegment here!! // because any changes after writing the .si will be // lost... // Must write deleted docs after the CFS so we don't // slurp the del file into CFS: if (flushedSegment.liveDocs != null) { int delCount = flushedSegment.delCount; Debug.Assert(delCount > 0); if (infoStream.IsEnabled("DWPT")) { infoStream.Message("DWPT", "flush: write " + delCount + " deletes gen=" + flushedSegment.segmentInfo.DelGen); } // TODO: we should prune the segment if it's 100% // deleted... but merge will also catch it. // TODO: in the NRT case it'd be better to hand // this del vector over to the // shortly-to-be-opened SegmentReader and let it // carry the changes; there's no reason to use // filesystem as intermediary here. SegmentCommitInfo info = flushedSegment.segmentInfo; Codec codec = info.Info.Codec; codec.LiveDocsFormat.WriteLiveDocs(flushedSegment.liveDocs, directory, info, delCount, context); newSegment.DelCount = delCount; newSegment.AdvanceDelGen(); } success = true; } finally { if (!success) { if (infoStream.IsEnabled("DWPT")) { infoStream.Message("DWPT", "hit exception creating compound file for newly flushed segment " + newSegment.Info.Name); } } } }
public virtual ISet <object> keySet() { return(Collections.emptySet()); }
/// <summary> /// populate the items in collection. /// </summary> void PopulateCollections() { var RootNode1 = new GettingStartedModel { Header = "Work Documents" }; var RootNode2 = new GettingStartedModel { Header = "Personal Folder" }; var ChildNode1 = new GettingStartedModel { Header = "Functional Specifications" }; var ChildNode2 = new GettingStartedModel { Header = "TreeView spec" }; var ChildNode3 = new GettingStartedModel { Header = "Feature Schedule" }; var ChildNode4 = new GettingStartedModel { Header = "Overall Project Plan" }; var ChildNode5 = new GettingStartedModel { Header = "Feature Resource Allocation" }; var ChildNode6 = new GettingStartedModel { Header = "Home Remodel Folder" }; var ChildNode7 = new GettingStartedModel { Header = "Contractor Contact Info" }; var ChildNode8 = new GettingStartedModel { Header = "Paint Color Scheme" }; var ChildNode9 = new GettingStartedModel { Header = "Flooring Woodgrain type" }; var ChildNode10 = new GettingStartedModel { Header = "Kitchen Cabinet Style" }; var ChildNode11 = new GettingStartedModel { Header = "My Network Places" }; var ChildNode12 = new GettingStartedModel { Header = "Server" }; var ChildNode13 = new GettingStartedModel { Header = "My Folders" }; var ChildNode14 = new GettingStartedModel { Header = "My Computer" }; var ChildNode15 = new GettingStartedModel { Header = "Music" }; var ChildNode16 = new GettingStartedModel { Header = "Videos" }; var ChildNode17 = new GettingStartedModel { Header = "Wallpaper.png" }; var ChildNode18 = new GettingStartedModel { Header = "My Banner.png" }; var ChildNode19 = new GettingStartedModel { Header = "Favourites" }; var ChildNode20 = new GettingStartedModel { Header = "Image3.png" }; var ChildNode21 = new GettingStartedModel { Header = "Image4.png" }; var ChildNode22 = new GettingStartedModel { Header = "Image5.png" }; var ChildNode23 = new GettingStartedModel { Header = "Image1.png" }; var ChildNode24 = new GettingStartedModel { Header = "Image2.png" }; RootNode1.Childs.Add(ChildNode1); RootNode1.Childs.Add(ChildNode3); RootNode1.Childs.Add(ChildNode4); RootNode1.Childs.Add(ChildNode5); RootNode2.Childs.Add(ChildNode6); RootNode2.Childs.Add(ChildNode11); RootNode2.Childs.Add(ChildNode14); RootNode2.Childs.Add(ChildNode19); ChildNode1.Childs.Add(ChildNode2); ChildNode6.Childs.Add(ChildNode7); ChildNode6.Childs.Add(ChildNode8); ChildNode6.Childs.Add(ChildNode9); ChildNode6.Childs.Add(ChildNode10); ChildNode11.Childs.Add(ChildNode12); ChildNode11.Childs.Add(ChildNode13); ChildNode11.Childs.Add(ChildNode23); ChildNode11.Childs.Add(ChildNode24); ChildNode14.Childs.Add(ChildNode15); ChildNode14.Childs.Add(ChildNode16); ChildNode14.Childs.Add(ChildNode17); ChildNode14.Childs.Add(ChildNode18); ChildNode19.Childs.Add(ChildNode20); ChildNode19.Childs.Add(ChildNode21); ChildNode19.Childs.Add(ChildNode22); SelectedNodes = new ObservableCollection <object>(); SelectedNodes.Add(ChildNode1); SelectedNodes.Add(ChildNode4); SelectedNodes.Add(ChildNode8); Collections.Add(RootNode1); Collections.Add(RootNode2); }
private void dgEvaluaciones_Loaded(List <Area> areaspc) { Collections col = new Collections(); List <Area> areas = col.ReadAllAreas(); List <Competencia> competencias = col.ReadAllCompetencias();/**//**/ List <float> brechas = new List <float>(); List <PerfildeCargo> perfilesdecargo = new List <PerfildeCargo>(); //Calcular cantidad máxima de notas, para definir el ancho de la tabla int nbrechas = 0; foreach (Area a in areas) { foreach (Area item in areaspc) { if (a.ID_AREA == item.ID_AREA) { foreach (Competencia com in competencias) { brechas = col.ObtenerNotasCompetencia((int)a.ID_AREA, (int)com.ID_COMPETENCIA);/**//**/ if (brechas.Count > nbrechas) { nbrechas = brechas.Count; } } } } } //dar formato a la tabla DataTable table = new DataTable(); DataColumn column; column = table.Columns.Add(); column.ColumnName = "Cargo"; column.DataType = typeof(string); column = table.Columns.Add(); column.ColumnName = "Competencia"; column.DataType = typeof(string); if (nbrechas > 0) { for (int i = 0; i < nbrechas; i++) { column = table.Columns.Add(); column.ColumnName = "N" + (i + 1); column.DataType = typeof(string); } } column = table.Columns.Add(); column.ColumnName = "Brecha Promedio"; column.DataType = typeof(string); //Final formato tabla //Listar resultados en la tabla DataRow row; float sumabrechas = 0; foreach (Area a in areas) { foreach (Area item in areaspc) { if (a.ID_AREA == item.ID_AREA) { foreach (Competencia com in competencias) { sumabrechas = 0; brechas = col.ObtenerNotasCompetencia((int)a.ID_AREA, (int)com.ID_COMPETENCIA);/**//**/ if (brechas.Count > 0) { row = table.NewRow(); row["Cargo"] = a.NOMBRE; row["Competencia"] = com.NOMBRE; for (int i = 0; i < brechas.Count; i++) { row["N" + (i + 1)] = brechas[i]; sumabrechas = brechas[i] + sumabrechas; } float brpromedio = sumabrechas / brechas.Count; row["Brecha Promedio"] = brpromedio.ToString("0.0"); if (bajonivelesperado == true && Convert.ToDecimal(brpromedio) < com.NIVEL_OPTIMO_ESPERADO) { table.Rows.Add(row); } if (bajonivelesperado == false) { table.Rows.Add(row); } } } } } } dgEvaluaciones.ItemsSource = table.AsDataView(); }
public virtual TokenInfoDictionaryWriter BuildDictionary(IList<string> csvFiles) { TokenInfoDictionaryWriter dictionary = new TokenInfoDictionaryWriter(10 * 1024 * 1024); // all lines in the file Console.WriteLine(" parse..."); List<string[]> lines = new List<string[]>(400000); foreach (string file in csvFiles) { using (Stream inputStream = new FileStream(file, FileMode.Open, FileAccess.Read)) { Encoding decoder = Encoding.GetEncoding(encoding); TextReader reader = new StreamReader(inputStream, decoder); string line = null; while ((line = reader.ReadLine()) != null) { string[] entry = CSVUtil.Parse(line); if (entry.Length < 13) { Console.WriteLine("Entry in CSV is not valid: " + line); continue; } string[] formatted = FormatEntry(entry); lines.Add(formatted); // NFKC normalize dictionary entry if (normalizeEntries) { //if (normalizer.isNormalized(entry[0])){ if (entry[0].IsNormalized(NormalizationForm.FormKC)) { continue; } string[] normalizedEntry = new string[entry.Length]; for (int i = 0; i < entry.Length; i++) { //normalizedEntry[i] = normalizer.normalize(entry[i]); normalizedEntry[i] = entry[i].Normalize(NormalizationForm.FormKC); } formatted = FormatEntry(normalizedEntry); lines.Add(formatted); } } } } Console.WriteLine(" sort..."); // sort by term: we sorted the files already and use a stable sort. lines.Sort(new ComparerAnonymousHelper()); Console.WriteLine(" encode..."); PositiveInt32Outputs fstOutput = PositiveInt32Outputs.Singleton; Builder<long?> fstBuilder = new Builder<long?>(Lucene.Net.Util.Fst.FST.INPUT_TYPE.BYTE2, 0, 0, true, true, int.MaxValue, fstOutput, null, true, PackedInt32s.DEFAULT, true, 15); Int32sRef scratch = new Int32sRef(); long ord = -1; // first ord will be 0 string lastValue = null; // build tokeninfo dictionary foreach (string[] entry in lines) { int next = dictionary.Put(entry); if (next == offset) { Console.WriteLine("Failed to process line: " + Collections.ToString(entry)); continue; } string token = entry[0]; if (!token.Equals(lastValue, StringComparison.Ordinal)) { // new word to add to fst ord++; lastValue = token; scratch.Grow(token.Length); scratch.Length = token.Length; for (int i = 0; i < token.Length; i++) { scratch.Int32s[i] = (int)token[i]; } fstBuilder.Add(scratch, ord); } dictionary.AddMapping((int)ord, offset); offset = next; } FST<long?> fst = fstBuilder.Finish(); Console.WriteLine(" " + fst.NodeCount + " nodes, " + fst.ArcCount + " arcs, " + fst.GetSizeInBytes() + " bytes... "); dictionary.SetFST(fst); Console.WriteLine(" done"); return dictionary; }
public virtual void shouldAuthorizeSetRemovalTimeForHistoricBatchesBatch() { // given string batchId = engineRule.HistoryService.deleteHistoricProcessInstancesAsync(Collections.singletonList(processInstance.Id), "aDeleteReason").Id; authRule.init(scenario).withUser("userId").bindResource("batchId", "*").start(); HistoricBatchQuery query = historyService.createHistoricBatchQuery().batchId(batchId); // when historyService.setRemovalTimeToHistoricBatches().absoluteRemovalTime(DateTime.Now).byQuery(query).executeAsync(); // then authRule.assertScenario(scenario); // clear database managementService.deleteBatch(batchId, true); }
// TODO: add support for WikipediaTokenizer's advanced options. public override Tokenizer Create(AttributeSource.AttributeFactory factory, TextReader input) { return(new WikipediaTokenizer(factory, input, WikipediaTokenizer.TOKENS_ONLY, Collections.EmptyList <string>())); }
public void InitializeCultureFormatList(Collections.SelectableListNodeList list) { GuiHelper.Initialize(_guiCultures, list); }
// **** Sets up member variables related to camera **** private void SetUpCameraOutputs(int width, int height) { var activity = Activity; var manager = (CameraManager)activity.GetSystemService(Context.CameraService); try { // Loop through all of the cameras for (var i = 0; i < manager.GetCameraIdList().Length; i++) { var cameraId = manager.GetCameraIdList()[i]; CameraCharacteristics characteristics = manager.GetCameraCharacteristics(cameraId); // We don't want the front facing camera. This is for selfies. var facing = (Integer)characteristics.Get(CameraCharacteristics.LensFacing); if (facing != null && facing == (Integer.ValueOf((int)LensFacing.Front))) { continue; } // This returns the sizes of the previews // We neded to match this with our screen var map = (StreamConfigurationMap)characteristics.Get(CameraCharacteristics.ScalerStreamConfigurationMap); if (map == null) { continue; } // For still image captures, we use the largest available size. Size largest = (Size)Collections.Max(Arrays.AsList(map.GetOutputSizes((int)ImageFormatType.Jpeg)), new CompareSizesByArea()); mImageReader = ImageReader.NewInstance(largest.Width, largest.Height, ImageFormatType.Jpeg, /*maxImages*/ 2); mImageReader.SetOnImageAvailableListener(mOnImageAvailableListener, mBackgroundHandler); // Find out if we need to swap dimensions to get the preview size relative to the sensor // coordinate. var displayRotation = activity.WindowManager.DefaultDisplay.Rotation; //noinspection ConstantConditions mSensorOrientation = (int)characteristics.Get(CameraCharacteristics.SensorOrientation); bool swappedDimensions = false; switch (displayRotation) { case SurfaceOrientation.Rotation0: case SurfaceOrientation.Rotation180: if (mSensorOrientation == 90 || mSensorOrientation == 270) { swappedDimensions = true; } break; case SurfaceOrientation.Rotation90: case SurfaceOrientation.Rotation270: if (mSensorOrientation == 0 || mSensorOrientation == 180) { swappedDimensions = true; } break; default: Log.Error(TAG, "Display rotation is invalid: " + displayRotation); break; } Point displaySize = new Point(); activity.WindowManager.DefaultDisplay.GetSize(displaySize); var rotatedPreviewWidth = width; var rotatedPreviewHeight = height; var maxPreviewWidth = displaySize.X; var maxPreviewHeight = displaySize.Y; if (swappedDimensions) { rotatedPreviewWidth = height; rotatedPreviewHeight = width; maxPreviewWidth = displaySize.Y; maxPreviewHeight = displaySize.X; } if (maxPreviewWidth > MAX_PREVIEW_WIDTH) { maxPreviewWidth = MAX_PREVIEW_WIDTH; } if (maxPreviewHeight > MAX_PREVIEW_HEIGHT) { maxPreviewHeight = MAX_PREVIEW_HEIGHT; } // Danger, W.R.! Attempting to use too large a preview size could exceed the camera // bus's bandwidth limitation, resulting in gorgeous previews but the storage of // garbage capture data. mPreviewSize = ChooseOptimalSize(map.GetOutputSizes(Class.FromType(typeof(SurfaceTexture))), rotatedPreviewWidth, rotatedPreviewHeight, maxPreviewWidth, maxPreviewHeight, largest); // We fit the aspect ratio of TextureView to the size of the preview we picked. var orientation = Resources.Configuration.Orientation; if (orientation == Orientation.Landscape) { mTextureView.SetAspectRatio(mPreviewSize.Width, mPreviewSize.Height); } else { mTextureView.SetAspectRatio(mPreviewSize.Height, mPreviewSize.Width); } // Check if the flash is supported. var available = (Boolean)characteristics.Get(CameraCharacteristics.FlashInfoAvailable); if (available == null) { mFlashSupported = false; } else { mFlashSupported = (bool)available; } mCameraId = cameraId; return; } } catch (CameraAccessException e) { e.PrintStackTrace(); } catch (NullPointerException e) { string exception = e.ToString(); // Currently an NPE is thrown when the Camera2API is used but not supported on the // device this code runs. ErrorDialog.NewInstance(GetString(Resource.String.camera_error)).Show(ChildFragmentManager, FRAGMENT_DIALOG); } }
int BuildHtml( List<ListViewItem> in_items, List<ListViewItem> outof_items, out List<string> filenames, out string strError) { strError = ""; int nRet = 0; Hashtable macro_table = new Hashtable(); string strNamePath = "inventory_printoption"; // 获得打印参数 PrintOption option = new ItemHandoverPrintOption(this.MainForm.DataDir, this.comboBox_load_type.Text); option.LoadData(this.MainForm.AppInfo, strNamePath); macro_table["%date%"] = DateTime.Now.ToLongDateString(); macro_table["%barcodefilepath%"] = ""; macro_table["%barcodefilename%"] = ""; macro_table["%recpathfilepath%"] = ""; macro_table["%recpathfilename%"] = ""; if (this.SourceStyle == "barcodefile") { macro_table["%barcodefilepath%"] = this.BarcodeFilePath; macro_table["%barcodefilename%"] = Path.GetFileName(this.BarcodeFilePath); } else if (this.SourceStyle == "recpathfile") { macro_table["%recpathfilepath%"] = this.RecPathFilePath; macro_table["%recpathfilename%"] = Path.GetFileName(this.RecPathFilePath); } filenames = new List<string>(); // 这个数组存放了所有文件名 string strFileNamePrefix = this.MainForm.DataDir + "\\~inventory"; string strFileName = ""; Collections in_cols = new Collections(); Collections out_cols = new Collections(); // 统计集合 nRet = Count(in_items, ref in_cols, out strError); if (nRet == -1) return -1; // 统计集合 nRet = Count(outof_items, ref out_cols, out strError); if (nRet == -1) return -1; // 输出统计信息页 { macro_table["%scancount%"] = (in_cols.Scaned.Count + out_cols.DataBorrowed.Count + out_cols.DataOnShelf.Count).ToString(); macro_table["%incount%"] = in_items.Count.ToString(); macro_table["%borrowedcount%"] = in_cols.Borrowed.Count.ToString(); macro_table["%onshelfcount%"] = in_cols.OnShelf.Count.ToString(); macro_table["%notreturncount%"] = in_cols.OnShelfBorrowed.Count.ToString(); macro_table["%lostcount%"] = in_cols.Lost.Count.ToString(); macro_table["%outcount%"] = outof_items.Count.ToString(); macro_table["%datadir%"] = this.MainForm.DataDir; // 便于引用datadir下templates目录内的某些文件 macro_table["%cssfilepath%"] = this.GetAutoCssUrl(option, "itemhandover.css"); // 便于引用服务器端或“css”模板的CSS文件 strFileName = strFileNamePrefix + "0" + ".html"; filenames.Add(strFileName); string strTemplateFilePath = option.GetTemplatePageFilePath("统计页"); string strContent = ""; if (String.IsNullOrEmpty(strTemplateFilePath) == true) strContent = @"<html> <head> <LINK href='%cssfilepath%' type='text/css' rel='stylesheet'> </head> <body> <div class='pageheader'>%date% 盘点概况</div> <div class='tabletitle'>%date% 盘点概况 -- %barcodefilepath%</div> <div class='scancount'>数据采集册数: %scancount%</div> <div class='sepline'><hr/></div> <div class='incount'>集合内册数: %incount%</div> <div class='borrowedcount'>借出册数: %borrowedcount%</div> <div class='onshelfcount'>在架册数: %onshelfcount%</div> <div class='notreturncount'>在架错为外借册数: %notreturncount%</div> <div class='lostcount'>丢失册数: %lostcount%</div> <div class='sepline'><hr/></div> <div class='outcount'>集合外册数: %outcount%</div> <div class='sepline'><hr/></div> <div class='pagefooter'></div> </body> </html>"; else { // 根据模板打印 // 能自动识别文件内容的编码方式的读入文本文件内容模块 // return: // -1 出错 // 0 文件不存在 // 1 文件存在 nRet = Global.ReadTextFileContent(strTemplateFilePath, out strContent, out strError); if (nRet == -1) return -1; } string strResult = StringUtil.MacroString(macro_table, strContent); StreamUtil.WriteText(strFileName, strResult); } #if NO // 表格页循环 for (int i = 0; i < nTablePageCount; i++) { macro_table["%pageno%"] = (i + 1 + 1).ToString(); strFileName = strFileNamePrefix + (i + 1).ToString() + ".html"; filenames.Add(strFileName); BuildPageTop(option, macro_table, strFileName, true); // 行循环 for (int j = 0; j < option.LinesPerPage; j++) { BuildTableLine(option, in_items, strFileName, i, j); } BuildPageBottom(option, macro_table, strFileName, true); } /* for (int i = 0; i < this.listView_in.Items.Count; i++) { } * */ #endif return 0; }
public UnregisterDeploymentCmd(string deploymentId) : this(Collections.singleton(deploymentId)) { }
void Roles_ItemsRemoved(object sender, Collections.CollectionItemsChangedEventArgs<Collections.IndexedItem<Role>> e) { foreach (var u in e.Items) { Content.DeleteRoleAsync(u.Value, PluginInfrastructure.ErrorHandling.ShowErrorDialog); } }
public void TestSchemaObjectArray() { _epService.EPAdministrator.CreateEPL("create objectarray schema MyEvent(p0 string, p1 long)"); RunAssertionOA(false); RunAssertionOA(true); // test collector _epService.EPAdministrator.CreateEPL("create dataflow MyDataFlowOne " + "EventBusSource -> ReceivedStream<MyEvent> {filter: p0 like 'A%'} " + "DefaultSupportCaptureOp(ReceivedStream) {}"); MyCollector collector = new MyCollector(); DefaultSupportCaptureOp future = new DefaultSupportCaptureOp(); EPDataFlowInstantiationOptions options = new EPDataFlowInstantiationOptions() .OperatorProvider(new DefaultSupportGraphOpProvider(future)) .ParameterProvider(new DefaultSupportGraphParamProvider(Collections.SingletonDataMap("collector", collector))); EPDataFlowInstance instance = _epService.EPRuntime.DataFlowRuntime.Instantiate("MyDataFlowOne", options); instance.Start(); _epService.EPRuntime.SendEvent(new Object[] { "B", 100L }, "MyEvent"); Thread.Sleep(50); Assert.IsNull(collector.GetLast()); _epService.EPRuntime.SendEvent(new Object[] { "A", 101L }, "MyEvent"); future.WaitForInvocation(100, 1); Assert.NotNull(collector.GetLast().Emitter); Assert.AreEqual("MyEvent", collector.GetLast().Event.EventType.Name); Assert.AreEqual(false, collector.GetLast().IsSubmitEventBean); }
/// <summary> /// Overrides to recover by last sample's index instead. /// </summary> /// <param name="renderer"></param> /// <param name="options"></param> protected override void Reconfigure( string renderer, Collections.NameValuePairList options ) { this.LastViewCategory = this.CategoryMenu.SelectionIndex; this.LastViewTitle = this.SampleMenu.SelectionIndex; this.LastSampleIndex = -1; int index = -1; foreach ( Sample i in this.LoadedSamples ) { index++; if ( i == CurrentSample ) { this.LastSampleIndex = index; break; } } base.Reconfigure( renderer, options ); }
private void EffectPools_ItemRemoved(object sender, Collections.ObservableCollectionEventArgs<EffectPool> e) { RemoveEffectPool(e.Item); }
/// <exception cref="System.IO.IOException"/> public override void CacheGroupsAdd(IList <string> groups) { Log.Info("Adding " + groups + " to groups."); Collections.AddAll(allGroups, groups); }
private void AddMapEventType() { var top = Collections.SingletonDataMap("item", typeof(IDictionary <string, object>)); _epService.EPAdministrator.Configuration.AddEventType(SupportEventInfra.MAP_TYPENAME, top); }
private void effectPool_EffectRemoved(object sender, Collections.ObservableCollectionEventArgs<Effect> e) { RemoveEffect(e.Item); }
static PortugueseContractionUtility() { IDictionary <string, string> elems = new Dictionary <string, string>(); // 103 CONTRACTIONS. elems["a+a"] = "\u00e0"; elems["a+as"] = "\u00e0s"; elems["a+aquele"] = "\u00e0quele"; elems["a+aqueles"] = "\u00e0queles"; elems["a+aquela"] = "\u00e0quela"; elems["a+aquelas"] = "\u00e0quelas"; elems["a+aquilo"] = "\u00e0quilo"; elems["a+o"] = "ao"; elems["a+os"] = "aos"; elems["com+mim"] = "comigo"; elems["com+n\u00f2s"] = "conosco"; elems["com+si"] = "consigo"; elems["com+ti"] = "contigo"; elems["com+v\u00f2s"] = "convosco"; elems["de+a\u00ed"] = "da\u00ed"; elems["de+algu\u00e9m"] = "dalgu\u00e9m"; elems["de+algum"] = "dalgum"; elems["de+alguma"] = "dalguma"; elems["de+alguns"] = "dalguns"; elems["de+algumas"] = "dalgumas"; elems["de+ali"] = "dali"; elems["de+aqu\u00e9m"] = "daqu\u00e9m"; elems["de+aquele"] = "daquele"; elems["de+aquela"] = "daquela"; elems["de+aqueles"] = "daqueles"; elems["de+aquelas"] = "daquelas"; elems["de+aqui"] = "daqui"; elems["de+aquilo"] = "daquilo"; elems["de+ele"] = "dele"; elems["de+ela"] = "dela"; elems["de+eles"] = "deles"; elems["de+elas"] = "delas"; elems["de+entre"] = "dentre"; elems["de+esse"] = "desse"; elems["de+essa"] = "dessa"; elems["de+esses"] = "desses"; elems["de+essas"] = "dessas"; elems["de+este"] = "deste"; elems["de+esta"] = "desta"; elems["de+estes"] = "destes"; elems["de+estas"] = "destas"; elems["de+isso"] = "disso"; elems["de+isto"] = "disto"; elems["de+o"] = "do"; elems["de+a"] = "da"; elems["de+os"] = "dos"; elems["de+as"] = "das"; elems["de+outrem"] = "doutrem"; elems["de+outro"] = "doutro"; elems["de+outra"] = "doutra"; elems["de+outros"] = "doutros"; elems["de+outras"] = "doutras"; elems["de+um"] = "dum"; elems["de+uma"] = "duma"; elems["de+uns"] = "duns"; elems["de+umas"] = "dumas"; elems["esse+outro"] = "essoutro"; elems["essa+outra"] = "essoutra"; elems["este+outro"] = "estoutro"; elems["este+outra"] = "estoutra"; elems["ele+o"] = "lho"; elems["ele+a"] = "lha"; elems["ele+os"] = "lhos"; elems["ele+as"] = "lhas"; elems["em+algum"] = "nalgum"; elems["em+alguma"] = "nalguma"; elems["em+alguns"] = "nalguns"; elems["em+algumas"] = "nalgumas"; elems["em+aquele"] = "naquele"; elems["em+aquela"] = "naquela"; elems["em+aqueles"] = "naqueles"; elems["em+aquelas"] = "naquelas"; elems["em+aquilo"] = "naquilo"; elems["em+ele"] = "nele"; elems["em+ela"] = "nela"; elems["em+eles"] = "neles"; elems["em+elas"] = "nelas"; elems["em+esse"] = "nesse"; elems["em+essa"] = "nessa"; elems["em+esses"] = "nesses"; elems["em+essas"] = "nessas"; elems["em+este"] = "neste"; elems["em+esta"] = "nesta"; elems["em+estes"] = "nestes"; elems["em+estas"] = "nestas"; elems["em+isso"] = "nisso"; elems["em+isto"] = "nisto"; elems["em+o"] = "no"; elems["em+a"] = "na"; elems["em+os"] = "nos"; elems["em+as"] = "nas"; elems["em+outro"] = "noutro"; elems["em+outra"] = "noutra"; elems["em+outros"] = "noutros"; elems["em+outras"] = "noutras"; elems["em+um"] = "num"; elems["em+uma"] = "numa"; elems["em+uns"] = "nuns"; elems["em+umas"] = "numas"; elems["por+o"] = "pelo"; elems["por+a"] = "pela"; elems["por+os"] = "pelos"; elems["por+as"] = "pelas"; elems["para+a"] = "pra"; elems["para+o"] = "pro"; elems["para+as"] = "pras"; elems["para+os"] = "pros"; CONTRACTIONS = Collections.unmodifiableMap(elems); }
public void ComboBox_Initialize(Collections.SelectableListNodeList items, Collections.SelectableListNode defaultItem) { _cbComboBox.ItemsSource = null; _cbComboBox.ItemsSource = items; _cbComboBox.SelectedItem = defaultItem; }
/// <summary> /// Creates a new instance of the <see cref="WikipediaTokenizer"/>. Attaches the /// <paramref name="input"/> to a newly created JFlex scanner. /// </summary> /// <param name="input"> The Input <see cref="TextReader"/> </param> public WikipediaTokenizer(TextReader input) : this(input, TOKENS_ONLY, Collections.EmptySet <string>()) { }