public virtual void AddChildNodes(ICollection<ExprNode> childNodeColl) { ChildNodes = (ExprNode[]) CollectionUtil.ArrayExpandAddElements(ChildNodes, childNodeColl); }
public override void Flush(IDictionary <string, TermsHashConsumerPerField> fieldsToFlush, SegmentWriteState state) { // Gather all FieldData's that have postings, across all // ThreadStates IList <FreqProxTermsWriterPerField> allFields = new List <FreqProxTermsWriterPerField>(); foreach (TermsHashConsumerPerField f in fieldsToFlush.Values) { FreqProxTermsWriterPerField perField = (FreqProxTermsWriterPerField)f; if (perField.termsHashPerField.bytesHash.Count > 0) { allFields.Add(perField); } } int numAllFields = allFields.Count; // Sort by field name CollectionUtil.IntroSort(allFields); FieldsConsumer consumer = state.SegmentInfo.Codec.PostingsFormat.FieldsConsumer(state); bool success = false; try { TermsHash termsHash = null; /* * Current writer chain: * FieldsConsumer * -> IMPL: FormatPostingsTermsDictWriter * -> TermsConsumer * -> IMPL: FormatPostingsTermsDictWriter.TermsWriter * -> DocsConsumer * -> IMPL: FormatPostingsDocsWriter * -> PositionsConsumer * -> IMPL: FormatPostingsPositionsWriter */ for (int fieldNumber = 0; fieldNumber < numAllFields; fieldNumber++) { FieldInfo fieldInfo = allFields[fieldNumber].fieldInfo; FreqProxTermsWriterPerField fieldWriter = allFields[fieldNumber]; // If this field has postings then add them to the // segment fieldWriter.Flush(fieldInfo.Name, consumer, state); TermsHashPerField perField = fieldWriter.termsHashPerField; if (Debugging.AssertsEnabled) { Debugging.Assert(termsHash == null || termsHash == perField.termsHash); } termsHash = perField.termsHash; int numPostings = perField.bytesHash.Count; perField.Reset(); perField.ShrinkHash(numPostings); fieldWriter.Reset(); } if (termsHash != null) { termsHash.Reset(); } success = true; } finally { if (success) { IOUtils.Dispose(consumer); } else { IOUtils.DisposeWhileHandlingException(consumer); } } }
public virtual void runTestQuery(SpatialMatchConcern concern, SpatialTestQuery q) { String msg = q.toString(); //"Query: " + q.args.toString(ctx); SearchResults got = executeQuery(makeQuery(q), Math.Max(100, q.ids.size() + 1)); if (storeShape && got.numFound > 0) { //check stored value is there assertNotNull(got.results[0].document.Get(strategy.FieldName)); } if (concern.orderIsImportant) { IEnumerator <String> ids = q.ids.GetEnumerator(); foreach (SearchResult r in got.results) { String id = r.document.Get("id"); if (!ids.MoveNext()) { fail(msg + " :: Did not get enough results. Expect" + q.ids + ", got: " + got.toDebugString()); } assertEquals("out of order: " + msg, ids.Current, id); } if (ids.MoveNext()) { fail(msg + " :: expect more results then we got: " + ids.Current); } } else { // We are looking at how the results overlap if (concern.resultsAreSuperset) { ISet <string> found = new HashSet <string>(); foreach (SearchResult r in got.results) { found.add(r.document.Get("id")); } foreach (String s in q.ids) { if (!found.contains(s)) { fail("Results are mising id: " + s + " :: " + found); } } } else { List <string> found = new List <string>(); foreach (SearchResult r in got.results) { found.Add(r.document.Get("id")); } // sort both so that the order is not important CollectionUtil.TimSort(q.ids); CollectionUtil.TimSort(found); assertEquals(msg, q.ids.toString(), found.toString()); } } }
public AttributeOverrideDateTime(string name, IDictionary <long, DateTime> values) : base(name) { ArgumentAssert.IsNotEmpty(values, "values"); CollectionUtil.UnionDictionaries(_values, values); }
public override bool IsExistsProperty(EventBean eventBean) { var array = BaseNestableEventUtil.CheckedCastUnderlyingObjectArray(eventBean); return CollectionUtil.ArrayExistsAtIndex((Array) array[propertyIndex], index); }
/// <summary> /// Returns a key-value pair collection that represents the current <see cref="T:PropertyBag"/>. /// </summary> /// <returns>A <see cref="IDictionary{T,U}"/> instance that represents the current <see cref="T:PropertyBag"/>.</returns> internal IDictionary <string, object> ToDictionary() { return(CollectionUtil.NewDictionary(_bag)); }
public static GroupByClauseExpressions GetGroupByRollupExpressions( IList <GroupByClauseElement> groupByElements, SelectClauseSpecRaw selectClauseSpec, ExprNode optionalHavingNode, IList <OrderByItem> orderByList, ExprNodeSubselectDeclaredDotVisitor visitor) { if (groupByElements == null || groupByElements.Count == 0) { return(null); } // walk group-by-elements, determine group-by expressions and rollup nodes var groupByExpressionInfo = GroupByToRollupNodes(groupByElements); // obtain expression nodes, collect unique nodes and assign index var distinctGroupByExpressions = new List <ExprNode>(); var expressionToIndex = new Dictionary <ExprNode, int>(); foreach (ExprNode exprNode in groupByExpressionInfo.Expressions) { var found = false; for (var i = 0; i < distinctGroupByExpressions.Count; i++) { ExprNode other = distinctGroupByExpressions[i]; // find same expression if (ExprNodeUtility.DeepEquals(exprNode, other)) { expressionToIndex.Put(exprNode, i); found = true; break; } } // not seen before if (!found) { expressionToIndex.Put(exprNode, distinctGroupByExpressions.Count); distinctGroupByExpressions.Add(exprNode); } } // determine rollup, validate it is either (not both) var hasGroupingSet = false; var hasRollup = false; foreach (var element in groupByElements) { if (element is GroupByClauseElementGroupingSet) { hasGroupingSet = true; } if (element is GroupByClauseElementRollupOrCube) { hasRollup = true; } } // no-rollup or grouping-sets means simply validate var groupByExpressions = distinctGroupByExpressions.ToArray(); if (!hasRollup && !hasGroupingSet) { return(new GroupByClauseExpressions(groupByExpressions)); } // evaluate rollup node roots IList <GroupByRollupNodeBase> nodes = groupByExpressionInfo.Nodes; var perNodeCombinations = new Object[nodes.Count][]; var context = new GroupByRollupEvalContext(expressionToIndex); try { for (var i = 0; i < nodes.Count; i++) { var node = nodes[i]; var combinations = node.Evaluate(context); perNodeCombinations[i] = new Object[combinations.Count]; for (var j = 0; j < combinations.Count; j++) { perNodeCombinations[i][j] = combinations[j]; } } } catch (GroupByRollupDuplicateException ex) { if (ex.Indexes.Length == 0) { throw new ExprValidationException("Failed to validate the group-by clause, found duplicate specification of the overall grouping '()'"); } else { var writer = new StringWriter(); var delimiter = ""; for (var i = 0; i < ex.Indexes.Length; i++) { writer.Write(delimiter); writer.Write(groupByExpressions[ex.Indexes[i]].ToExpressionStringMinPrecedenceSafe()); delimiter = ", "; } throw new ExprValidationException("Failed to validate the group-by clause, found duplicate specification of expressions (" + writer.ToString() + ")"); } } // enumerate combinations building an index list var combinationEnumeration = new CombinationEnumeration(perNodeCombinations); ICollection <int> combination = new SortedSet <int>(); ICollection <MultiKeyInt> indexList = new LinkedHashSet <MultiKeyInt>(); while (combinationEnumeration.MoveNext()) { combination.Clear(); Object[] combinationOA = combinationEnumeration.Current; foreach (var indexes in combinationOA) { var indexarr = (int[])indexes; foreach (var anIndex in indexarr) { combination.Add(anIndex); } } var indexArr = CollectionUtil.IntArray(combination); indexList.Add(new MultiKeyInt(indexArr)); } // obtain rollup levels var rollupLevels = new int[indexList.Count][]; var count = 0; foreach (var mk in indexList) { rollupLevels[count++] = mk.Keys; } var numberOfLevels = rollupLevels.Length; if (numberOfLevels == 1 && rollupLevels[0].Length == 0) { throw new ExprValidationException("Failed to validate the group-by clause, the overall grouping '()' cannot be the only grouping"); } // obtain select-expression copies for rewrite var expressions = selectClauseSpec.SelectExprList; var selects = new ExprNode[numberOfLevels][]; for (var i = 0; i < numberOfLevels; i++) { selects[i] = new ExprNode[expressions.Count]; for (var j = 0; j < expressions.Count; j++) { SelectClauseElementRaw selectRaw = expressions[j]; if (!(selectRaw is SelectClauseExprRawSpec)) { throw new ExprValidationException("Group-by with rollup requires that the select-clause does not use wildcard"); } var compiled = (SelectClauseExprRawSpec)selectRaw; selects[i][j] = CopyVisitExpression(compiled.SelectExpression, visitor); } } // obtain having-expression copies for rewrite ExprNode[] optHavingNodeCopy = null; if (optionalHavingNode != null) { optHavingNodeCopy = new ExprNode[numberOfLevels]; for (var i = 0; i < numberOfLevels; i++) { optHavingNodeCopy[i] = CopyVisitExpression(optionalHavingNode, visitor); } } // obtain orderby-expression copies for rewrite ExprNode[][] optOrderByCopy = null; if (orderByList != null && orderByList.Count > 0) { optOrderByCopy = new ExprNode[numberOfLevels][]; for (var i = 0; i < numberOfLevels; i++) { optOrderByCopy[i] = new ExprNode[orderByList.Count]; for (var j = 0; j < orderByList.Count; j++) { OrderByItem element = orderByList[j]; optOrderByCopy[i][j] = CopyVisitExpression(element.ExprNode, visitor); } } } return(new GroupByClauseExpressions(groupByExpressions, rollupLevels, selects, optHavingNodeCopy, optOrderByCopy)); }
public void Run(RegressionEnvironment env) { var path = new RegressionPath(); var eplSchema = "create schema Lvl1(Intarr int[]);\n" + "@public @buseventtype create schema Lvl0(Lvl1 Lvl1, IndexNumber int, Id string);\n"; env.CompileDeploy(eplSchema, path); var epl = "@Name('s0') select " + "Lvl1.Intarr[IndexNumber] as c0, " + "Lvl1.Intarr.size() as c1, " + "me.Lvl1.Intarr[IndexNumber] as c2, " + "me.Lvl1.Intarr.size() as c3 " + "from Lvl0 as me"; env.CompileDeploy(soda, epl, path).AddListener("s0"); var fields = "c0,c1,c2,c3".SplitCsv(); var @out = env.Statement("s0").EventType; foreach (var field in fields) { Assert.AreEqual(typeof(int?), @out.GetPropertyType(field)); } var Lvl1 = CollectionUtil.BuildMap("Intarr", new int?[] { 1, 2, 3 }); var Lvl0 = CollectionUtil.BuildMap("Lvl1", Lvl1, "IndexNumber", 2); env.SendEventMap(Lvl0, "Lvl0"); AssertProps(env.Listener("s0").AssertOneGetNewAndReset(), fields, 3, 3, 3, 3); // Invalid tests // not an index expression TryInvalidCompile( env, path, "select Lvl1[IndexNumber] from Lvl0", "Failed to validate select-clause expression 'Lvl1[IndexNumber]': Invalid array operation for property 'Lvl1'"); TryInvalidCompile( env, path, "select me.Lvl1[IndexNumber] from Lvl0 as me", "Failed to validate select-clause expression 'me.Lvl1[IndexNumber]': Invalid array operation for property 'Lvl1'"); // two index expressions TryInvalidCompile( env, path, "select Lvl1.Intarr[IndexNumber, IndexNumber] from Lvl0", "Failed to validate select-clause expression 'Lvl1.Intarr[IndexNumber,IndexNumber]': Incorrect number of index expressions for array operation, expected a single expression returning an integer value but received 2 expressions for operation on type array of System.Nullable<System.Int32>"); TryInvalidCompile( env, path, "select me.Lvl1.Intarr[IndexNumber, IndexNumber] from Lvl0 as me", "Failed to validate select-clause expression 'me.Lvl1.Intarr[IndexNumber,IndexNumber]': Incorrect number of index expressions for array operation, expected a single expression returning an integer value but received 2 expressions for operation on type array of System.Nullable<System.Int32>"); // double-array TryInvalidCompile( env, path, "select Lvl1.Intarr[IndexNumber][IndexNumber] from Lvl0", "Failed to validate select-clause expression 'Lvl1.Intarr[IndexNumber][IndexNumber]': Could not perform array operation on type class System.Nullable<System.Int32>"); TryInvalidCompile( env, path, "select me.Lvl1.Intarr[IndexNumber][IndexNumber] from Lvl0 as me", "Failed to validate select-clause expression 'me.Lvl1.Intarr[IndexNumber][IndexNumber]': Could not perform array operation on type class System.Nullable<System.Int32>"); // wrong index expression type TryInvalidCompile( env, path, "select Lvl1.Intarr[Id] from Lvl0", "Failed to validate select-clause expression 'Lvl1.Intarr[Id]': Incorrect index expression for array operation, expected an expression returning an integer value but the expression 'Id' returns 'System.String' for operation on type array of System.Nullable<System.Int32>"); TryInvalidCompile( env, path, "select me.Lvl1.Intarr[Id] from Lvl0 as me", "Failed to validate select-clause expression 'me.Lvl1.Intarr[Id]': Incorrect index expression for array operation, expected an expression returning an integer value but the expression 'Id' returns 'System.String' for operation on type array of System.Nullable<System.Int32>"); env.UndeployAll(); }
public void Run(RegressionEnvironment env) { Validate(env, "{1, 2, 3}.aggregate(0, (result, value) => result + value)", 6); Validate(env, "{1, 2, 3}.aggregate(0, (result, value, index) => result + value + index*10)", 36); Validate(env, "{1, 2, 3}.aggregate(0, (result, value, index, size) => result + value + index*10 + size*100)", 936); Validate(env, "{1, 2, 3}.allOf(v => v > 0)", true); Validate(env, "{1, 2, 3}.allOf(v => v > 1)", false); Validate(env, "{1, 2, 3}.allOf((v, index) => case when index < 2 then true else v > 1 end)", true); Validate(env, "{1, 2, 3}.allOf((v, index, size) => v > 1 or size >= 3)", true); Validate(env, "{1, 2, 3}.anyOf(v => v > 1)", true); Validate(env, "{1, 2, 3}.anyOf(v => v > 3)", false); Validate(env, "{1, 2, 3}.anyOf( (v, index) => case when index < 2 then false else v = 3 end)", true); Validate(env, "{1, 2, 3}.anyOf( (v, index, size) => v > 100 or size >= 3)", true); Validate(env, "{1, 2, 3}.average()", 2.0); Validate(env, "{1, 2, 3}.average(v => v+1)", 3d); Validate(env, "{1, 2, 3}.average((v, index) => v+10*index)", 12d); Validate(env, "{1, 2, 3}.average((v, index, size) => v+10*index + 100*size)", 312d); Validate(env, "{1, 2, 3}.countOf()", 3); Validate(env, "{1, 2, 3}.countOf(v => v < 2)", 1); Validate(env, "{1, 2, 3}.countOf( (v, index) => v > index)", 3); Validate(env, "{1, 2, 3}.countOf( (v, index, size) => v >= size)", 1); Validate(env, "{1, 2, 3}.except({1})", new object[] { 2, 3 }); Validate(env, "{1, 2, 3}.intersect({2,3})", new object[] { 2, 3 }); Validate(env, "{1, 2, 3}.firstOf()", 1); Validate(env, "{1, 2, 3}.firstOf(v => v / 2 = 1)", 2); Validate(env, "{1, 2, 3}.firstOf((v, index) => index = 1)", 2); Validate(env, "{1, 2, 3}.firstOf((v, index, size) => v = size-1)", 2); Validate(env, "{1, 2, 3}.intersect({2, 3})", new object[] { 2, 3 }); Validate(env, "{1, 2, 3}.lastOf()", 3); Validate(env, "{1, 2, 3}.lastOf(v => v < 3)", 2); Validate(env, "{1, 2, 3}.lastOf((v, index) => index < 2 )", 2); Validate(env, "{1, 2, 3}.lastOf((v, index, size) => index < size - 2 )", 1); Validate(env, "{1, 2, 3, 2, 1}.leastFrequent()", 3); Validate(env, "{1, 2, 3, 2, 1}.leastFrequent(v => case when v = 3 then 4 else v end)", 4); Validate(env, "{1, 2, 3, 2, 1}.leastFrequent((v, index) => case when index = 2 then 4 else v end)", 4); Validate(env, "{1, 2, 3, 2, 1}.leastFrequent((v, index, size) => case when index = size - 2 then 4 else v end)", 2); Validate(env, "{1, 2, 3, 2, 1}.max()", 3); Validate(env, "{1, 2, 3, 2, 1}.max(v => case when v >= 3 then 0 else v end)", 2); Validate(env, "{1, 2, 3, 2, 1}.max((v, index) => case when index = 2 then 0 else v end)", 2); Validate(env, "{1, 2, 3, 2, 1}.max((v, index, size) => case when index > size - 4 then 0 else v end)", 2); Validate(env, "{1, 2, 3, 2, 1}.min()", 1); Validate(env, "{1, 2, 3, 2, 1}.min(v => v + 1)", 2); Validate(env, "{1, 2, 3, 2, 1}.min((v, index) => v - index)", -3); Validate(env, "{1, 2, 3, 2, 1}.min((v, index, size) => v - size)", -4); Validate(env, "{1, 2, 3, 2, 1, 2}.mostFrequent()", 2); Validate(env, "{1, 2, 3, 2, 1, 2}.mostFrequent(v => case when v = 2 then 10 else v end)", 10); Validate(env, "{1, 2, 3, 2, 1, 2}.mostFrequent((v, index) => case when index > 2 then 4 else v end)", 4); Validate(env, "{1, 2, 3, 2, 1, 2}.mostFrequent((v, index, size) => case when size > 3 then 0 else v end)", 0); Validate(env, "{2, 3, 2, 1}.orderBy()", new object[] { 1, 2, 2, 3 }); Validate(env, "{2, 3, 2, 1}.orderBy(v => -v)", new object[] { 3, 2, 2, 1 }); Validate(env, "{2, 3, 2, 1}.orderBy((v, index) => index)", new object[] { 2, 3, 2, 1 }); Validate(env, "{2, 3, 2, 1}.orderBy((v, index, size) => case when index < size - 2 then v else -v end)", new object[] { 2, 1, 2, 3 }); Validate(env, "{2, 3, 2, 1}.distinctOf()", new object[] { 2, 3, 1 }); Validate(env, "{2, 3, 2, 1}.distinctOf(v => case when v > 1 then 0 else -1 end)", new object[] { 2, 1 }); Validate(env, "{2, 3, 2, 1}.distinctOf((v, index) => case when index = 0 then 1 else 2 end)", new object[] { 2, 3 }); Validate(env, "{2, 3, 2, 1}.distinctOf((v, index, size) => case when index+1=size then 1 else 2 end)", new object[] { 2, 1 }); Validate(env, "{2, 3, 2, 1}.reverse()", new object[] { 1, 2, 3, 2 }); Validate(env, "{1, 2, 3}.sequenceEqual({1})", false); Validate(env, "{1, 2, 3}.sequenceEqual({1, 2, 3})", true); Validate(env, "{1, 2, 3}.sumOf()", 6); Validate(env, "{1, 2, 3}.sumOf(v => v+1)", 9); Validate(env, "{1, 2, 3}.sumOf((v, index) => v + index)", 1 + 3 + 5); Validate(env, "{1, 2, 3}.sumOf((v, index, size) => v+index+size)", 18); Validate(env, "{1, 2, 3}.take(2)", new object[] { 1, 2 }); Validate(env, "{1, 2, 3}.takeLast(2)", new object[] { 2, 3 }); Validate(env, "{1, 2, 3}.takeWhile(v => v < 3)", new object[] { 1, 2 }); Validate(env, "{1, 2, 3}.takeWhile((v,ind) => ind < 2)", new object[] { 1, 2 }); Validate(env, "{1, 2, -1, 4, 5, 6}.takeWhile((v,ind) => ind < 5 and v > 0)", new object[] { 1, 2 }); Validate(env, "{1, 2, -1, 4, 5, 6}.takeWhile((v,ind,sz) => ind < sz - 5 and v > 0)", new object[] { 1 }); Validate(env, "{1, 2, 3}.takeWhileLast(v => v > 1)", new object[] { 2, 3 }); Validate(env, "{1, 2, 3}.takeWhileLast((v,ind) => ind < 2)", new object[] { 2, 3 }); Validate(env, "{1, 2, -1, 4, 5, 6}.takeWhileLast((v,ind) => ind < 5 and v > 0)", new object[] { 4, 5, 6 }); Validate(env, "{1, 2, -1, 4, 5, 6}.takeWhileLast((v,ind,sz) => ind < sz-4 and v > 0)", new object[] { 5, 6 }); Validate(env, "{1, 2, 3}.union({4, 5})", new object[] { 1, 2, 3, 4, 5 }); Validate(env, "{1, 2, 3}.where(v => v != 2)", new object[] { 1, 3 }); Validate(env, "{1, 2, 3}.where((v, index) => v != 2 and index < 2)", new object[] { 1 }); Validate(env, "{1, 2, 3}.where((v, index, size) => v != 2 and index < size - 2)", new object[] { 1 }); Validate( env, "{1, 2, 3}.groupby(k => 'K' || Convert.ToString(k))", CollectionUtil.BuildMap("K1", SingletonList(1), "K2", SingletonList(2), "K3", SingletonList(3))); Validate( env, "{1, 2, 3}.groupby(k => 'K' || Convert.ToString(k), v => 'V' || Convert.ToString(v))", CollectionUtil.BuildMap("K1", SingletonList("V1"), "K2", SingletonList("V2"), "K3", SingletonList("V3"))); Validate( env, "{1, 2, 3}.groupby((k, i) => 'K' || Convert.ToString(k) || \"_\" || Convert.ToString(i), (v, i) => 'V' || Convert.ToString(v) || \"_\" || Convert.ToString(i))", CollectionUtil.BuildMap("K1_0", SingletonList("V1_0"), "K2_1", SingletonList("V2_1"), "K3_2", SingletonList("V3_2"))); Validate( env, "{1, 2, 3}.groupby((k, i, s) => 'K' || Convert.ToString(k) || \"_\" || Convert.ToString(s), (v, i, s) => 'V' || Convert.ToString(v) || \"_\" || Convert.ToString(s))", CollectionUtil.BuildMap("K1_3", SingletonList("V1_3"), "K2_3", SingletonList("V2_3"), "K3_3", SingletonList("V3_3"))); Validate(env, "{1, 2, 3, 2, 1}.maxby(v => v)", 3); Validate(env, "{1, 2, 3, 2, 1}.maxby((v, index) => case when index < 3 then -1 else 0 end)", 2); Validate(env, "{1, 2, 3, 2, 1}.maxby((v, index, size) => case when index < size - 2 then -1 else 0 end)", 2); Validate(env, "{1, 2, 3, 2, 1}.minby(v => v)", 1); Validate(env, "{1, 2, 3, 2, 1}.minby((v, index) => case when index < 3 then -1 else 0 end)", 1); Validate(env, "{1, 2, 3, 2, 1}.minby((v, index, size) => case when index < size - 2 then -1 else 0 end)", 1); Validate(env, "{'A','B','C'}.selectFrom(v => '<' || v || '>')", Arrays.AsList("<A>", "<B>", "<C>")); Validate(env, "{'A','B','C'}.selectFrom((v, index) => v || '_' || Convert.ToString(index))", Arrays.AsList("A_0", "B_1", "C_2")); Validate(env, "{'A','B','C'}.selectFrom((v, index, size) => v || '_' || Convert.ToString(size))", Arrays.AsList("A_3", "B_3", "C_3")); ValidateWithVerifier( env, "{1, 2, 3}.arrayOf()", result => EPAssertionUtil.AssertEqualsExactOrder(result.Unwrap <int>(), new int[] { 1, 2, 3 })); ValidateWithVerifier( env, "{1, 2, 3}.arrayOf(v => v+1)", result => EPAssertionUtil.AssertEqualsExactOrder(result.Unwrap <int>(), new int[] { 2, 3, 4 })); ValidateWithVerifier( env, "{1, 2, 3}.arrayOf((v, index) => v+index)", result => EPAssertionUtil.AssertEqualsExactOrder(result.Unwrap <int>(), new int[] { 1, 3, 5 })); ValidateWithVerifier( env, "{1, 2, 3}.arrayOf((v, index, size) => v+index+size)", result => EPAssertionUtil.AssertEqualsExactOrder(result.Unwrap <int>(), new int[] { 4, 6, 8 })); Validate( env, "{1, 2, 3}.toMap(k => 'K' || Convert.ToString(k), v => 'V' || Convert.ToString(v))", CollectionUtil.BuildMap("K1", "V1", "K2", "V2", "K3", "V3")); Validate( env, "{1, 2, 3}.toMap((k, i) => 'K' || Convert.ToString(k) || \"_\" || Convert.ToString(i), (v, i) => 'V' || Convert.ToString(v) || \"_\" || Convert.ToString(i))", CollectionUtil.BuildMap("K1_0", "V1_0", "K2_1", "V2_1", "K3_2", "V3_2")); Validate( env, "{1, 2, 3}.toMap((k, i, s) => 'K' || Convert.ToString(k) || \"_\" || Convert.ToString(s), (v, i, s) => 'V' || Convert.ToString(v) || \"_\" || Convert.ToString(s))", CollectionUtil.BuildMap("K1_3", "V1_3", "K2_3", "V2_3", "K3_3", "V3_3")); }
private void ValidateContextDetail( EPServicesContext servicesContext, StatementContext statementContext, ISet <string> eventTypesReferenced, ContextDetail contextDetail, AgentInstanceContext agentInstanceContext) { if (contextDetail is ContextDetailPartitioned) { var segmented = (ContextDetailPartitioned)contextDetail; foreach (var partition in segmented.Items) { ValidateNotTable(servicesContext, partition.FilterSpecRaw.EventTypeName); var raw = new FilterStreamSpecRaw(partition.FilterSpecRaw, ViewSpec.EMPTY_VIEWSPEC_ARRAY, null, new StreamSpecOptions()); var compiled = raw.Compile(statementContext, eventTypesReferenced, false, Collections.GetEmptyList <int>(), false, true, false, null); if (!(compiled is FilterStreamSpecCompiled)) { throw new ExprValidationException("Partition criteria may not include named windows"); } var result = (FilterStreamSpecCompiled)compiled; partition.FilterSpecCompiled = result.FilterSpec; } } else if (contextDetail is ContextDetailCategory) { // compile filter var category = (ContextDetailCategory)contextDetail; ValidateNotTable(servicesContext, category.FilterSpecRaw.EventTypeName); var raw = new FilterStreamSpecRaw(category.FilterSpecRaw, ViewSpec.EMPTY_VIEWSPEC_ARRAY, null, new StreamSpecOptions()); var result = (FilterStreamSpecCompiled)raw.Compile(statementContext, eventTypesReferenced, false, Collections.GetEmptyList <int>(), false, true, false, null); category.FilterSpecCompiled = result.FilterSpec; servicesContext.StatementEventTypeRefService.AddReferences(statementContext.StatementName, CollectionUtil.ToArray(eventTypesReferenced)); // compile expressions foreach (var item in category.Items) { ValidateNotTable(servicesContext, category.FilterSpecRaw.EventTypeName); var filterSpecRaw = new FilterSpecRaw(category.FilterSpecRaw.EventTypeName, Collections.SingletonList(item.Expression), null); var rawExpr = new FilterStreamSpecRaw(filterSpecRaw, ViewSpec.EMPTY_VIEWSPEC_ARRAY, null, new StreamSpecOptions()); var compiled = (FilterStreamSpecCompiled)rawExpr.Compile(statementContext, eventTypesReferenced, false, Collections.GetEmptyList <int>(), false, true, false, null); item.SetCompiledFilter(compiled.FilterSpec, agentInstanceContext); } } else if (contextDetail is ContextDetailHash) { var hashed = (ContextDetailHash)contextDetail; foreach (var hashItem in hashed.Items) { var raw = new FilterStreamSpecRaw(hashItem.FilterSpecRaw, ViewSpec.EMPTY_VIEWSPEC_ARRAY, null, new StreamSpecOptions()); ValidateNotTable(servicesContext, hashItem.FilterSpecRaw.EventTypeName); var result = (FilterStreamSpecCompiled)raw.Compile(statementContext, eventTypesReferenced, false, Collections.GetEmptyList <int>(), false, true, false, null); hashItem.FilterSpecCompiled = result.FilterSpec; // validate parameters var streamTypes = new StreamTypeServiceImpl(result.FilterSpec.FilterForEventType, null, true, statementContext.EngineURI); var validationContext = new ExprValidationContext( streamTypes, statementContext.EngineImportService, statementContext.StatementExtensionServicesContext, null, statementContext.SchedulingService, statementContext.VariableService, statementContext.TableService, GetDefaultAgentInstanceContext(statementContext), statementContext.EventAdapterService, statementContext.StatementName, statementContext.StatementId, statementContext.Annotations, statementContext.ContextDescriptor, statementContext.ScriptingService, false, false, false, false, null, false); ExprNodeUtility.Validate(ExprNodeOrigin.CONTEXT, Collections.SingletonList(hashItem.Function), validationContext); } } else if (contextDetail is ContextDetailInitiatedTerminated) { var def = (ContextDetailInitiatedTerminated)contextDetail; var startCondition = ValidateRewriteContextCondition(servicesContext, statementContext, def.Start, eventTypesReferenced, new MatchEventSpec(), new LinkedHashSet <string>()); var endCondition = ValidateRewriteContextCondition(servicesContext, statementContext, def.End, eventTypesReferenced, startCondition.Matches, startCondition.AllTags); def.Start = startCondition.Condition; def.End = endCondition.Condition; if (def.DistinctExpressions != null) { if (!(startCondition.Condition is ContextDetailConditionFilter)) { throw new ExprValidationException("Distinct-expressions require a stream as the initiated-by condition"); } var distinctExpressions = def.DistinctExpressions; if (distinctExpressions.Length == 0) { throw new ExprValidationException("Distinct-expressions have not been provided"); } var filter = (ContextDetailConditionFilter)startCondition.Condition; if (filter.OptionalFilterAsName == null) { throw new ExprValidationException("Distinct-expressions require that a stream name is assigned to the stream using 'as'"); } var types = new StreamTypeServiceImpl(filter.FilterSpecCompiled.FilterForEventType, filter.OptionalFilterAsName, true, servicesContext.EngineURI); var validationContext = new ExprValidationContext( types, statementContext.EngineImportService, statementContext.StatementExtensionServicesContext, null, statementContext.SchedulingService, statementContext.VariableService, statementContext.TableService, GetDefaultAgentInstanceContext(statementContext), statementContext.EventAdapterService, statementContext.StatementName, statementContext.StatementId, statementContext.Annotations, statementContext.ContextDescriptor, statementContext.ScriptingService, false, false, true, false, null, false); for (var i = 0; i < distinctExpressions.Length; i++) { ExprNodeUtility.ValidatePlainExpression(ExprNodeOrigin.CONTEXTDISTINCT, ExprNodeUtility.ToExpressionStringMinPrecedenceSafe(distinctExpressions[i]), distinctExpressions[i]); distinctExpressions[i] = ExprNodeUtility.GetValidatedSubtree(ExprNodeOrigin.CONTEXTDISTINCT, distinctExpressions[i], validationContext); } } } else if (contextDetail is ContextDetailNested) { var nested = (ContextDetailNested)contextDetail; foreach (var nestedContext in nested.Contexts) { ValidateContextDetail(servicesContext, statementContext, eventTypesReferenced, nestedContext.ContextDetail, agentInstanceContext); } } else { throw new IllegalStateException("Unrecognized context detail " + contextDetail); } }
public void Run(RegressionEnvironment env) { var path = new RegressionPath(); var epl = "create schema Lvl1(Id string);\n" + "@public @buseventtype create schema Lvl0(Lvl1 Lvl1[], IndexNumber int, Lvl0Id string);\n" + "@Name('s0') select Lvl1[IndexNumber].Id as c0, me.Lvl1[IndexNumber].Id as c1 from Lvl0 as me"; env.CompileDeploy(epl, path).AddListener("s0"); var fields = "c0,c1".SplitCsv(); var @out = env.Statement("s0").EventType; foreach (var field in fields) { Assert.AreEqual(typeof(string), @out.GetPropertyType(field)); } var Lvl1One = CollectionUtil.BuildMap("Id", "a"); var Lvl1Two = CollectionUtil.BuildMap("Id", "b"); var Lvl0 = CollectionUtil.BuildMap("Lvl1", new[] { Lvl1One, Lvl1Two }, "IndexNumber", 1); env.SendEventMap(Lvl0, "Lvl0"); AssertProps(env.Listener("s0").AssertOneGetNewAndReset(), fields, "b", "b"); // Invalid tests // array value but no array provided TryInvalidCompile( env, path, "select Lvl1.Id from Lvl0", "Failed to validate select-clause expression 'Lvl1.Id': Failed to resolve property 'Lvl1.Id' (property 'Lvl1' is an indexed property and requires an index or enumeration method to access values)"); TryInvalidCompile( env, path, "select me.Lvl1.Id from Lvl0 as me", "Failed to validate select-clause expression 'me.Lvl1.Id': Property named 'Lvl1.Id' is not valid in stream 'me' (did you mean 'Lvl0Id'?)"); // not an index expression TryInvalidCompile( env, path, "select Lvl1.Id[IndexNumber] from Lvl0", "Failed to validate select-clause expression 'Lvl1.Id[IndexNumber]': Could not find event property or method named 'Id' in collection of events of type 'Lvl1'"); TryInvalidCompile( env, path, "select me.Lvl1.Id[IndexNumber] from Lvl0 as me", "Failed to validate select-clause expression 'me.Lvl1.Id[IndexNumber]': Could not find event property or method named 'Id' in collection of events of type 'Lvl1'"); // two index expressions TryInvalidCompile( env, path, "select Lvl1[IndexNumber, IndexNumber].Id from Lvl0", "Failed to validate select-clause expression 'Lvl1[IndexNumber,IndexNumber].Id': Incorrect number of index expressions for array operation, expected a single expression returning an integer value but received 2 expressions for property 'Lvl1'"); TryInvalidCompile( env, path, "select me.Lvl1[IndexNumber, IndexNumber].Id from Lvl0 as me", "Failed to validate select-clause expression 'me.Lvl1[IndexNumber,IndexNumber].Id': Incorrect number of index expressions for array operation, expected a single expression returning an integer value but received 2 expressions for property 'Lvl1'"); // double-array TryInvalidCompile( env, path, "select Lvl1[IndexNumber][IndexNumber].Id from Lvl0", "Failed to validate select-clause expression 'Lvl1[IndexNumber][IndexNumber].Id': Could not perform array operation on type event type 'Lvl1'"); TryInvalidCompile( env, path, "select me.Lvl1[IndexNumber][IndexNumber].Id from Lvl0 as me", "Failed to validate select-clause expression 'me.Lvl1[IndexNumber][IndexNumber].Id': Could not perform array operation on type event type 'Lvl1'"); // wrong index expression type TryInvalidCompile( env, path, "select Lvl1[Lvl0Id].Id from Lvl0", "Failed to validate select-clause expression 'Lvl1[Lvl0Id].Id': Incorrect index expression for array operation, expected an expression returning an integer value but the expression 'Lvl0Id' returns 'System.String' for property 'Lvl1'"); TryInvalidCompile( env, path, "select me.Lvl1[Lvl0Id].Id from Lvl0 as me", "Failed to validate select-clause expression 'me.Lvl1[Lvl0Id].Id': Incorrect index expression for array operation, expected an expression returning an integer value but the expression 'Lvl0Id' returns 'System.String' for property 'Lvl1'"); env.UndeployAll(); }
public override EPStatementStartResult StartInternal( EPServicesContext services, StatementContext statementContext, bool isNewStatement, bool isRecoveringStatement, bool isRecoveringResilient) { if (_statementSpec.OptionalContextName != null) { throw new ExprValidationException("A create-context statement cannot itself be associated to a context, please declare a nested context instead"); } var context = _statementSpec.ContextDesc; var agentInstanceContext = GetDefaultAgentInstanceContext(statementContext); // compile filter specs, if any ISet <string> eventTypesReferenced = new HashSet <string>(); ValidateContextDetail(services, statementContext, eventTypesReferenced, context.ContextDetail, agentInstanceContext); services.StatementEventTypeRefService.AddReferences(statementContext.StatementName, CollectionUtil.ToArray(eventTypesReferenced)); // define output event type var typeName = "EventType_Context_" + context.ContextName; var statementResultEventType = services.EventAdapterService.CreateAnonymousMapType(typeName, Collections.GetEmptyMap <string, object>(), true); // add context - does not activate that context services.ContextManagementService.AddContextSpec(services, agentInstanceContext, context, isRecoveringResilient, statementResultEventType); EPStatementStopMethod stopMethod = new ProxyEPStatementStopMethod(() => { // no action }); EPStatementDestroyMethod destroyMethod = new ProxyEPStatementDestroyMethod(() => services.ContextManagementService.DestroyedContext(context.ContextName)); return(new EPStatementStartResult(new ZeroDepthStreamNoIterate(statementResultEventType), stopMethod, destroyMethod)); }
private bool Phase(Agent agent) { if (PhaseFrame.ContainsKey(agent.Unit.Tag) && Tyr.Bot.Frame - PhaseFrame[agent.Unit.Tag] <= 224) { return(false); } foreach (Unit unit in Tyr.Bot.Enemies()) { if (UnitTypes.BuildingTypes.Contains(unit.UnitType)) { continue; } if (agent.Unit.UnitType == UnitTypes.ZERGLING || agent.Unit.UnitType == UnitTypes.BROODLING || agent.Unit.UnitType == UnitTypes.EGG || agent.Unit.UnitType == UnitTypes.LARVA) { continue; } if (unit.IsFlying) { continue; } if (SC2Util.DistanceSq(unit.Pos, agent.Unit.Pos) > 10 * 10) { continue; } int count = 0; bool closeAlly = false; foreach (Agent ally in Tyr.Bot.UnitManager.Agents.Values) { if (ally.Unit.IsFlying) { continue; } if (ally.DistanceSq(unit) <= 2 * 2) { closeAlly = true; break; } } if (closeAlly) { break; } foreach (Unit unit2 in Tyr.Bot.Enemies()) { if (UnitTypes.BuildingTypes.Contains(unit.UnitType)) { continue; } if (unit.UnitType == UnitTypes.ZERGLING || agent.Unit.UnitType == UnitTypes.BROODLING || agent.Unit.UnitType == UnitTypes.EGG || agent.Unit.UnitType == UnitTypes.LARVA) { continue; } if (unit.IsFlying) { continue; } if (SC2Util.DistanceSq(unit.Pos, unit2.Pos) <= 3 * 3) { count++; } } if (count >= 6) { agent.Order(2346, SC2Util.To2D(unit.Pos)); CollectionUtil.Add(PhaseFrame, agent.Unit.Tag, Tyr.Bot.Frame); return(true); } } return(false); }
public virtual string ToString(string?format, IFormatProvider?formatProvider) => CollectionUtil.ToString(formatProvider, format, this);
//期待通りのエラーメッセージが出ていることを確認するために必要 public string GetDataAt(int index) { return(CollectionUtil.GetItemFromLinkedList(_items, index).Data); }
public void UpdateMergeTests() { ConnectorAttribute expected, actual; Configuration config = new MockConfiguration(false); ConnectorFacadeFactory factory = ConnectorFacadeFactory.GetInstance(); SafeType <Connector> clazz = SafeType <Connector> .Get <MockUpdateConnector>(); // **test only** APIConfiguration impl = TestHelpers.CreateTestConfiguration(clazz, config); impl.SetTimeout(SafeType <APIOperation> .Get <GetApiOp>(), APIConstants.NO_TIMEOUT); impl.SetTimeout(SafeType <APIOperation> .Get <UpdateApiOp>(), APIConstants.NO_TIMEOUT); impl.SetTimeout(SafeType <APIOperation> .Get <SearchApiOp>(), APIConstants.NO_TIMEOUT); ConnectorFacade facade = factory.NewInstance(impl); // sniff test to make sure we can get an object.. ConnectorObject obj = facade.GetObject(ObjectClass.ACCOUNT, NewUid(1), null); Assert.AreEqual(NewUid(1), obj.Uid); // ok lets add an attribute that doesn't exist.. String ADDED = "somthing to add to the object"; String ATTR_NAME = "added"; ICollection <ConnectorAttribute> addAttrSet; addAttrSet = CollectionUtil.NewSet((IEnumerable <ConnectorAttribute>)obj.GetAttributes()); addAttrSet.Add(ConnectorAttributeBuilder.Build(ATTR_NAME, ADDED)); Name name = obj.Name; addAttrSet.Remove(name); Uid uid = facade.AddAttributeValues(ObjectClass.ACCOUNT, obj.Uid, ConnectorAttributeUtil.FilterUid(addAttrSet), null); // get back the object and see if there are the same.. addAttrSet.Add(name); ConnectorObject addO = new ConnectorObject(ObjectClass.ACCOUNT, addAttrSet); obj = facade.GetObject(ObjectClass.ACCOUNT, NewUid(1), null); Assert.AreEqual(addO, obj); // attempt to add on to an existing attribute.. addAttrSet.Remove(name); uid = facade.AddAttributeValues(ObjectClass.ACCOUNT, obj.Uid, ConnectorAttributeUtil.FilterUid(addAttrSet), null); // get the object back out and check on it.. obj = facade.GetObject(ObjectClass.ACCOUNT, uid, null); expected = ConnectorAttributeBuilder.Build(ATTR_NAME, ADDED, ADDED); actual = obj.GetAttributeByName(ATTR_NAME); Assert.AreEqual(expected, actual); // attempt to delete a value from an attribute.. ICollection <ConnectorAttribute> deleteAttrs = CollectionUtil.NewSet((IEnumerable <ConnectorAttribute>)addO.GetAttributes()); deleteAttrs.Remove(name); uid = facade.RemoveAttributeValues(ObjectClass.ACCOUNT, addO.Uid, ConnectorAttributeUtil.FilterUid(deleteAttrs), null); obj = facade.GetObject(ObjectClass.ACCOUNT, uid, null); expected = ConnectorAttributeBuilder.Build(ATTR_NAME, ADDED); actual = obj.GetAttributeByName(ATTR_NAME); Assert.AreEqual(expected, actual); // attempt to delete an attribute that doesn't exist.. ICollection <ConnectorAttribute> nonExist = new HashSet <ConnectorAttribute>(); nonExist.Add(NewUid(1)); nonExist.Add(ConnectorAttributeBuilder.Build("does not exist", "asdfe")); uid = facade.RemoveAttributeValues(ObjectClass.ACCOUNT, addO.Uid, ConnectorAttributeUtil.FilterUid(nonExist), null); obj = facade.GetObject(ObjectClass.ACCOUNT, NewUid(1), null); Assert.IsTrue(obj.GetAttributeByName("does not exist") == null); }
/// <summary> /// Sort by score the list of <see cref="WeightedFragInfo"/> /// </summary> public override IList <WeightedFragInfo> GetWeightedFragInfoList(IList <WeightedFragInfo> src) { CollectionUtil.TimSort(src, new ScoreComparer()); return(src); }
public void UnionWith(IDictionary <string, int> indexes) { CollectionUtil.UnionDictionaries(this, indexes); }
public bool Fungal(Agent agent) { if (agent.Unit.Energy < 75) { return(false); } if (FungalTargets.ContainsKey(agent.Unit.Tag) && Tyr.Bot.Frame - FungalTargets[agent.Unit.Tag].Frame <= 22) { return(true); } foreach (UnitLocation mine in Tyr.Bot.EnemyMineManager.Mines) { bool closeFungal = false; foreach (FungalTarget fungal in FungalTargets.Values) { if (SC2Util.DistanceSq(mine.Pos, fungal.Pos) <= 3 * 3) { closeFungal = true; break; } } if (closeFungal) { continue; } if (SC2Util.DistanceSq(mine.Pos, agent.Unit.Pos) <= 10 * 10) { CollectionUtil.Add(FungalTargets, agent.Unit.Tag, new FungalTarget() { Pos = SC2Util.To2D(mine.Pos), Frame = Tyr.Bot.Frame, InfestorTag = agent.Unit.Tag }); agent.Order(74, SC2Util.To2D(mine.Pos)); return(true); } } foreach (Unit unit in Tyr.Bot.Enemies()) { if (UnitTypes.BuildingTypes.Contains(unit.UnitType)) { continue; } if (unit.UnitType == UnitTypes.ZERGLING || unit.UnitType == UnitTypes.BROODLING || unit.UnitType == UnitTypes.OVERLORD) { continue; } bool closeFungal = false; foreach (FungalTarget fungal in FungalTargets.Values) { if (SC2Util.DistanceSq(unit.Pos, fungal.Pos) <= 4 * 4) { closeFungal = true; break; } } if (closeFungal) { continue; } if (unit.UnitType == UnitTypes.BANSHEE || unit.UnitType == UnitTypes.TEMPEST || (unit.UnitType == UnitTypes.BATTLECRUISER && unit.Health < 200)) { CollectionUtil.Add(FungalTargets, agent.Unit.Tag, new FungalTarget() { Pos = SC2Util.To2D(unit.Pos), Frame = Tyr.Bot.Frame, InfestorTag = agent.Unit.Tag }); agent.Order(74, SC2Util.To2D(unit.Pos)); return(true); } if (SC2Util.DistanceSq(unit.Pos, agent.Unit.Pos) <= 10 * 10) { int count = 0; foreach (Unit unit2 in Tyr.Bot.Enemies()) { if (UnitTypes.BuildingTypes.Contains(unit.UnitType)) { continue; } if (unit.UnitType == UnitTypes.ZERGLING || unit.UnitType == UnitTypes.BROODLING || unit.UnitType == UnitTypes.OVERLORD) { continue; } if (SC2Util.DistanceSq(unit.Pos, unit2.Pos) <= 3 * 3) { count++; } } if (count >= 6) { CollectionUtil.Add(FungalTargets, agent.Unit.Tag, new FungalTarget() { Pos = SC2Util.To2D(unit.Pos), Frame = Tyr.Bot.Frame, InfestorTag = agent.Unit.Tag }); agent.Order(74, SC2Util.To2D(unit.Pos)); return(true); } } } return(false); }
public void OnFrame(Tyr tyr) { Counts = new Dictionary <uint, int>(); CompletedCounts = new Dictionary <uint, int>(); HashSet <ulong> existingUnits = new HashSet <ulong>(); foreach (Base b in tyr.BaseManager.Bases) { b.BuildingCounts = new Dictionary <uint, int>(); b.BuildingsCompleted = new Dictionary <uint, int>(); } ActiveOrders = new HashSet <uint>(); FoodExpected = 0; // Update our unit set. foreach (Unit unit in tyr.Observation.Observation.RawData.Units) { if (unit.Owner == tyr.PlayerId) { // Count how many of each unitType we have. CollectionUtil.Increment(Counts, unit.UnitType); if (UnitTypes.EquivalentTypes.ContainsKey(unit.UnitType)) { foreach (uint t in UnitTypes.EquivalentTypes[unit.UnitType]) { CollectionUtil.Increment(Counts, t); } } if (unit.BuildProgress >= 0.9999f) { CollectionUtil.Increment(CompletedCounts, unit.UnitType); if (UnitTypes.EquivalentTypes.ContainsKey(unit.UnitType)) { foreach (uint t in UnitTypes.EquivalentTypes[unit.UnitType]) { CollectionUtil.Increment(CompletedCounts, t); } } } if (unit.Orders != null && unit.Orders.Count > 0 && Abilities.Creates.ContainsKey(unit.Orders[0].AbilityId)) { CollectionUtil.Increment(Counts, Abilities.Creates[unit.Orders[0].AbilityId]); } if (unit.BuildProgress < 1 && unit.UnitType == UnitTypes.PYLON) { FoodExpected += 8; } if (unit.Orders != null && unit.Orders.Count > 0 && unit.Orders[0].AbilityId == 1344) { FoodExpected += 8; } if (unit.Orders != null && unit.Orders.Count > 0 && unit.Orders[0].AbilityId == 1216) { CollectionUtil.Increment(Counts, UnitTypes.LAIR); } if (unit.UnitType == UnitTypes.EGG) { CollectionUtil.Increment(Counts, Abilities.Creates[unit.Orders[0].AbilityId]); } existingUnits.Add(unit.Tag); if (Agents.ContainsKey(unit.Tag)) { Agent agent = Agents[unit.Tag]; agent.Unit = unit; if (unit.UnitType == UnitTypes.LARVA && agent.LastAbility >= 0 && Abilities.Creates.ContainsKey((uint)agent.LastAbility)) { CollectionUtil.Increment(Counts, Abilities.Creates[(uint)agent.LastAbility]); } agent.Command = null; if (agent.Base != null) { CollectionUtil.Increment(agent.Base.BuildingCounts, unit.UnitType); if (unit.BuildProgress >= 0.9999f) { CollectionUtil.Increment(agent.Base.BuildingsCompleted, unit.UnitType); } } } else { if (DisappearedUnits.ContainsKey(unit.Tag)) { Agents.Add(unit.Tag, DisappearedUnits[unit.Tag]); DisappearedUnits[unit.Tag].Unit = unit; } else { Agent agent = new Agent(unit); Agents.Add(unit.Tag, agent); tyr.TaskManager.NewAgent(agent); } } if (unit.Orders != null && unit.Orders.Count > 0) { ActiveOrders.Add(unit.Orders[0].AbilityId); } } } foreach (BuildRequest request in ConstructionTask.Task.BuildRequests) { // Count how many of each unitType we intend to build. CollectionUtil.Increment(Counts, request.Type); if (request.Type == UnitTypes.PYLON) { FoodExpected += 8; } if (request.Base != null) { CollectionUtil.Increment(request.Base.BuildingCounts, request.Type); } if (request.worker.Unit.Orders == null || request.worker.Unit.Orders.Count == 0 || request.worker.Unit.Orders[0].AbilityId != BuildingType.LookUp[request.Type].Ability) { tyr.ReservedMinerals += BuildingType.LookUp[request.Type].Minerals; tyr.ReservedGas += BuildingType.LookUp[request.Type].Gas; string workerAbility = ""; if (request.worker.Unit.Orders != null && request.worker.Unit.Orders.Count > 0) { workerAbility = " Ability: " + request.worker.Unit.Orders[0].AbilityId; } tyr.DrawText("Reserving: " + BuildingType.LookUp[request.Type].Name + workerAbility); } } foreach (BuildRequest request in ConstructionTask.Task.UnassignedRequests) { // Count how many of each unitType we intend to build. CollectionUtil.Increment(Counts, request.Type); FoodExpected += 8; if (request.Base != null) { CollectionUtil.Increment(request.Base.BuildingCounts, request.Type); } tyr.ReservedMinerals += BuildingType.LookUp[request.Type].Minerals; tyr.ReservedGas += BuildingType.LookUp[request.Type].Gas; tyr.DrawText("Reserving: " + BuildingType.LookUp[request.Type].Name); } // Remove dead units. if (tyr.Observation != null && tyr.Observation.Observation != null && tyr.Observation.Observation.RawData != null && tyr.Observation.Observation.RawData.Event != null && tyr.Observation.Observation.RawData.Event.DeadUnits != null) { foreach (ulong deadUnit in tyr.Observation.Observation.RawData.Event.DeadUnits) { Agents.Remove(deadUnit); } } }
//public static void main( string[] args ) throws Exception { // Analyzer analyzer = new WhitespaceAnalyzer(Version.LUCENE_CURRENT); // QueryParser parser = new QueryParser(Version.LUCENE_CURRENT, "f", analyzer ); // Query query = parser.parse( "a x:b" ); // FieldQuery fieldQuery = new FieldQuery( query, true, false ); // Directory dir = new RAMDirectory(); // IndexWriter writer = new IndexWriter(dir, new IndexWriterConfig(Version.LUCENE_CURRENT, analyzer)); // Document doc = new Document(); // IndexableFieldType ft = new IndexableFieldType(TextField.TYPE_STORED); // ft.setStoreTermVectors(true); // ft.setStoreTermVectorOffsets(true); // ft.setStoreTermVectorPositions(true); // doc.add( new Field( "f", ft, "a a a b b c a b b c d e f" ) ); // doc.add( new Field( "f", ft, "b a b a f" ) ); // writer.addDocument( doc ); // writer.close(); // IndexReader reader = IndexReader.open(dir1); // new FieldTermStack( reader, 0, "f", fieldQuery ); // reader.close(); //} /// <summary> /// a constructor. /// </summary> /// <param name="reader"><see cref="IndexReader"/> of the index</param> /// <param name="docId">document id to be highlighted</param> /// <param name="fieldName">field of the document to be highlighted</param> /// <param name="fieldQuery"><see cref="FieldQuery"/> object</param> /// <exception cref="IOException">If there is a low-level I/O error</exception> public FieldTermStack(IndexReader reader, int docId, string fieldName, FieldQuery fieldQuery) { this.fieldName = fieldName; ISet <string> termSet = fieldQuery.GetTermSet(fieldName); // just return to make null snippet if un-matched fieldName specified when fieldMatch == true if (termSet == null) { return; } Fields vectors = reader.GetTermVectors(docId); if (vectors == null) { // null snippet return; } Terms vector = vectors.GetTerms(fieldName); if (vector == null) { // null snippet return; } CharsRef spare = new CharsRef(); TermsEnum termsEnum = vector.GetEnumerator(); DocsAndPositionsEnum dpEnum = null; BytesRef text; int numDocs = reader.MaxDoc; while (termsEnum.MoveNext()) { text = termsEnum.Term; UnicodeUtil.UTF8toUTF16(text, spare); string term = spare.ToString(); if (!termSet.Contains(term)) { continue; } dpEnum = termsEnum.DocsAndPositions(null, dpEnum); if (dpEnum == null) { // null snippet return; } dpEnum.NextDoc(); // For weight look here: http://lucene.apache.org/core/3_6_0/api/core/org/apache/lucene/search/DefaultSimilarity.html float weight = (float)(Math.Log(numDocs / (double)(reader.DocFreq(new Term(fieldName, text)) + 1)) + 1.0); int freq = dpEnum.Freq; for (int i = 0; i < freq; i++) { int pos = dpEnum.NextPosition(); if (dpEnum.StartOffset < 0) { return; // no offsets, null snippet } termList.Add(new TermInfo(term, dpEnum.StartOffset, dpEnum.EndOffset, pos, weight)); } } // sort by position CollectionUtil.TimSort(termList); // now look for dups at the same position, linking them together int currentPos = -1; TermInfo previous = null; TermInfo first = null; for (int i = 0; i < termList.Count;) { TermInfo current = termList[i]; if (current.Position == currentPos) { if (Debugging.AssertsEnabled) { Debugging.Assert(previous != null); } previous.SetNext(current); previous = current; //iterator.Remove(); // LUCENENET NOTE: Remove, but don't advance the i position (since removing will advance to the next item) termList.RemoveAt(i); } else { if (previous != null) { previous.SetNext(first); } previous = first = current; currentPos = current.Position; // LUCENENET NOTE: Only increment the position if we don't do a delete. i++; } } if (previous != null) { previous.SetNext(first); } }
protected internal virtual void IndexInstruction(IValidatingMigrationInstruction instruction) { CollectionUtil.AddToMapOfLists(InstructionsBySourceScope, instruction.SourceActivity, instruction); CollectionUtil.AddToMapOfLists(InstructionsByTargetScope, instruction.TargetActivity, instruction); }
/// <summary> /// Called whenever the running merges have changed, to pause & unpause /// threads. This method sorts the merge threads by their merge size in /// descending order and then pauses/unpauses threads from first to last -- /// that way, smaller merges are guaranteed to run before larger ones. /// </summary> protected virtual void UpdateMergeThreads() { lock (this) { // Only look at threads that are alive & not in the // process of stopping (ie have an active merge): IList <MergeThread> activeMerges = new List <MergeThread>(); int threadIdx = 0; while (threadIdx < m_mergeThreads.Count) { MergeThread mergeThread = m_mergeThreads[threadIdx]; if (!mergeThread.IsAlive) { // Prune any dead threads m_mergeThreads.RemoveAt(threadIdx); continue; } if (mergeThread.CurrentMerge != null) { activeMerges.Add(mergeThread); } threadIdx++; } // Sort the merge threads in descending order. CollectionUtil.TimSort(activeMerges, compareByMergeDocCount); int pri = mergeThreadPriority; int activeMergeCount = activeMerges.Count; for (threadIdx = 0; threadIdx < activeMergeCount; threadIdx++) { MergeThread mergeThread = activeMerges[threadIdx]; MergePolicy.OneMerge merge = mergeThread.CurrentMerge; if (merge == null) { continue; } // pause the thread if maxThreadCount is smaller than the number of merge threads. bool doPause = threadIdx < activeMergeCount - maxThreadCount; if (IsVerbose) { if (doPause != merge.IsPaused) { if (doPause) { Message("pause thread " + mergeThread.Name); } else { Message("unpause thread " + mergeThread.Name); } } } if (doPause != merge.IsPaused) { merge.SetPause(doPause); } if (!doPause) { if (IsVerbose) { Message("set priority of merge thread " + mergeThread.Name + " to " + pri); } mergeThread.SetThreadPriority((ThreadPriority)pri); pri = Math.Min((int)ThreadPriority.Highest, 1 + pri); } } } }
/// <summary> /// /// </summary> /// <param name="processInstanceExecution"></param> protected internal virtual void HandleProcessInstanceExecution(IExecutionEntity processInstanceExecution) { IExecutionEntityManager executionEntityManager = commandContext.ExecutionEntityManager; string processInstanceId = processInstanceExecution.Id; // No parent execution == process instance id logger.LogDebug($"No parent execution found. Verifying if process instance {processInstanceId} can be stopped."); IExecutionEntity superExecution = processInstanceExecution.SuperExecution; ISubProcessActivityBehavior subProcessActivityBehavior = null; // copy variables before destroying the ended sub process instance (call activity) if (superExecution != null) { FlowNode superExecutionElement = (FlowNode)superExecution.CurrentFlowElement; subProcessActivityBehavior = (ISubProcessActivityBehavior)superExecutionElement.Behavior; try { subProcessActivityBehavior.Completing(superExecution, processInstanceExecution); } //catch (Exception e) //{ // //logger.error("Error while completing sub process of execution {}", processInstanceExecution, e); // throw e; //} catch (Exception e) { logger.LogError($"Error while completing sub process of execution {processInstanceExecution}.Exception Message: {e.Message}"); throw new ActivitiException("Error while completing sub process of execution " + processInstanceExecution, e); } } int activeExecutions = GetNumberOfActiveChildExecutionsForProcessInstance(executionEntityManager, processInstanceId, superExecution); if (activeExecutions == 0) { logger.LogDebug($"No active executions found. Ending process instance {processInstanceId} "); // note the use of execution here vs processinstance execution for getting the flowelement executionEntityManager.DeleteProcessInstanceExecutionEntity(processInstanceId, execution.CurrentFlowElement?.Id, null, false, false); } else { logger.LogDebug($"Active executions found. Process instance {processInstanceId} will not be ended."); } Process process = ProcessDefinitionUtil.GetProcess(processInstanceExecution.ProcessDefinitionId); // Execute execution listeners for process end. if (CollectionUtil.IsNotEmpty(process.ExecutionListeners)) { ExecuteExecutionListeners(process, processInstanceExecution, BaseExecutionListenerFields.EVENTNAME_END); } // and trigger execution afterwards if doing a call activity if (superExecution != null) { superExecution.SubProcessInstance = null; try { subProcessActivityBehavior.Completed(superExecution); } //catch (Exception e) //{ // logger.error("Error while completing sub process of execution {}", processInstanceExecution, e); // throw e; //} catch (Exception e) { logger.LogError($"Error while completing sub process of execution {processInstanceExecution}. Exception Messgae: {e.Message}."); throw new ActivitiException("Error while completing sub process of execution " + processInstanceExecution, e); } } }
public IEnumerable <AttributeInfo> GetAllowedAttributes(IPsiSourceFile sourceFile, int offset, bool strict = false) { return(CollectionUtil.EnumerateAll(OwnAttributes, InheritedAttributes, declaredElementsCache.GetAdditionalAttributesForTag(sourceFile, this, offset, strict))); }
/// <summary> /// Initialize the deleter: find all previous commits in /// the <see cref="Directory"/>, incref the files they reference, call /// the policy to let it delete commits. this will remove /// any files not referenced by any of the commits. </summary> /// <exception cref="IOException"> if there is a low-level IO error </exception> public IndexFileDeleter(Directory directory, IndexDeletionPolicy policy, SegmentInfos segmentInfos, InfoStream infoStream, IndexWriter writer, bool initialIndexExists) { this.infoStream = infoStream; this.writer = writer; string currentSegmentsFile = segmentInfos.GetSegmentsFileName(); if (infoStream.IsEnabled("IFD")) { infoStream.Message("IFD", "init: current segments file is \"" + currentSegmentsFile + "\"; deletionPolicy=" + policy); } this.policy = policy; this.directory = directory; // First pass: walk the files and initialize our ref // counts: long currentGen = segmentInfos.Generation; CommitPoint currentCommitPoint = null; string[] files = null; try { files = directory.ListAll(); } #pragma warning disable 168 catch (DirectoryNotFoundException e) #pragma warning restore 168 { // it means the directory is empty, so ignore it. files = new string[0]; } if (currentSegmentsFile != null) { Regex r = IndexFileNames.CODEC_FILE_PATTERN; foreach (string fileName in files) { if (!fileName.EndsWith("write.lock", StringComparison.Ordinal) && !fileName.Equals(IndexFileNames.SEGMENTS_GEN, StringComparison.Ordinal) && (r.IsMatch(fileName) || fileName.StartsWith(IndexFileNames.SEGMENTS, StringComparison.Ordinal))) { // Add this file to refCounts with initial count 0: GetRefCount(fileName); if (fileName.StartsWith(IndexFileNames.SEGMENTS, StringComparison.Ordinal)) { // this is a commit (segments or segments_N), and // it's valid (<= the max gen). Load it, then // incref all files it refers to: if (infoStream.IsEnabled("IFD")) { infoStream.Message("IFD", "init: load commit \"" + fileName + "\""); } SegmentInfos sis = new SegmentInfos(); try { sis.Read(directory, fileName); } #pragma warning disable 168 catch (FileNotFoundException e) #pragma warning restore 168 { // LUCENE-948: on NFS (and maybe others), if // you have writers switching back and forth // between machines, it's very likely that the // dir listing will be stale and will claim a // file segments_X exists when in fact it // doesn't. So, we catch this and handle it // as if the file does not exist if (infoStream.IsEnabled("IFD")) { infoStream.Message("IFD", "init: hit FileNotFoundException when loading commit \"" + fileName + "\"; skipping this commit point"); } sis = null; } // LUCENENET specific - .NET (thankfully) only has one FileNotFoundException, so we don't need this //catch (NoSuchFileException) //{ // // LUCENE-948: on NFS (and maybe others), if // // you have writers switching back and forth // // between machines, it's very likely that the // // dir listing will be stale and will claim a // // file segments_X exists when in fact it // // doesn't. So, we catch this and handle it // // as if the file does not exist // if (infoStream.IsEnabled("IFD")) // { // infoStream.Message("IFD", "init: hit FileNotFoundException when loading commit \"" + fileName + "\"; skipping this commit point"); // } // sis = null; //} // LUCENENET specific - since NoSuchDirectoryException subclasses FileNotFoundException // in Lucene, we need to catch it here to be on the safe side. catch (System.IO.DirectoryNotFoundException) { // LUCENE-948: on NFS (and maybe others), if // you have writers switching back and forth // between machines, it's very likely that the // dir listing will be stale and will claim a // file segments_X exists when in fact it // doesn't. So, we catch this and handle it // as if the file does not exist if (infoStream.IsEnabled("IFD")) { infoStream.Message("IFD", "init: hit FileNotFoundException when loading commit \"" + fileName + "\"; skipping this commit point"); } sis = null; } catch (IOException /*e*/) { if (SegmentInfos.GenerationFromSegmentsFileName(fileName) <= currentGen && directory.FileLength(fileName) > 0) { throw; // LUCENENET: CA2200: Rethrow to preserve stack details (https://docs.microsoft.com/en-us/visualstudio/code-quality/ca2200-rethrow-to-preserve-stack-details) } else { // Most likely we are opening an index that // has an aborted "future" commit, so suppress // exc in this case sis = null; } } if (sis != null) { CommitPoint commitPoint = new CommitPoint(commitsToDelete, directory, sis); if (sis.Generation == segmentInfos.Generation) { currentCommitPoint = commitPoint; } commits.Add(commitPoint); IncRef(sis, true); if (lastSegmentInfos == null || sis.Generation > lastSegmentInfos.Generation) { lastSegmentInfos = sis; } } } } } } if (currentCommitPoint == null && currentSegmentsFile != null && initialIndexExists) { // We did not in fact see the segments_N file // corresponding to the segmentInfos that was passed // in. Yet, it must exist, because our caller holds // the write lock. this can happen when the directory // listing was stale (eg when index accessed via NFS // client with stale directory listing cache). So we // try now to explicitly open this commit point: SegmentInfos sis = new SegmentInfos(); try { sis.Read(directory, currentSegmentsFile); } catch (IOException e) { throw new CorruptIndexException("failed to locate current segments_N file \"" + currentSegmentsFile + "\"" + e.ToString(), e); } if (infoStream.IsEnabled("IFD")) { infoStream.Message("IFD", "forced open of current segments file " + segmentInfos.GetSegmentsFileName()); } currentCommitPoint = new CommitPoint(commitsToDelete, directory, sis); commits.Add(currentCommitPoint); IncRef(sis, true); } // We keep commits list in sorted order (oldest to newest): CollectionUtil.TimSort(commits); // Now delete anything with ref count at 0. These are // presumably abandoned files eg due to crash of // IndexWriter. foreach (KeyValuePair <string, RefCount> entry in refCounts) { RefCount rc = entry.Value; string fileName = entry.Key; if (0 == rc.count) { if (infoStream.IsEnabled("IFD")) { infoStream.Message("IFD", "init: removing unreferenced file \"" + fileName + "\""); } DeleteFile(fileName); } } // Finally, give policy a chance to remove things on // startup: this.policy.OnInit(commits); // Always protect the incoming segmentInfos since // sometime it may not be the most recent commit Checkpoint(segmentInfos, false); startingCommitDeleted = currentCommitPoint == null ? false : currentCommitPoint.IsDeleted; DeleteCommits(); }
private ExprDotEvalParam GetBodyAndParameter( String enumMethodUsedName, int parameterNum, ExprNode parameterNode, EventType inputEventType, Type collectionComponentType, ExprValidationContext validationContext, IList <ExprDotEvalParam> priorParameters, DotMethodFP footprint) { // handle an expression that is a constant or other (not =>) if (!(parameterNode is ExprLambdaGoesNode)) { // no node subtree validation is required here, the chain parameter validation has taken place in ExprDotNode.validate // validation of parameter types has taken place in footprint matching return(new ExprDotEvalParamExpr(parameterNum, parameterNode, parameterNode.ExprEvaluator)); } var goesNode = (ExprLambdaGoesNode)parameterNode; // Get secondary var additionalTypes = GetAddStreamTypes( enumMethodUsedName, goesNode.GoesToNames, inputEventType, collectionComponentType, priorParameters, validationContext.EventAdapterService); var additionalStreamNames = goesNode.GoesToNames.ToArray(); ValidateDuplicateStreamNames(validationContext.StreamTypeService.StreamNames, additionalStreamNames); // add name and type to list of known types var addTypes = (EventType[]) CollectionUtil.ArrayExpandAddElements( validationContext.StreamTypeService.EventTypes, additionalTypes); var addNames = (String[]) CollectionUtil.ArrayExpandAddElements( validationContext.StreamTypeService.StreamNames, additionalStreamNames); var types = new StreamTypeServiceImpl( addTypes, addNames, new bool[addTypes.Length], null, false); // validate expression body var filter = goesNode.ChildNodes[0]; try { var filterValidationContext = new ExprValidationContext(types, validationContext); filter = ExprNodeUtility.GetValidatedSubtree(ExprNodeOrigin.DECLAREDEXPRBODY, filter, filterValidationContext); } catch (ExprValidationException ex) { throw new ExprValidationException( "Error validating enumeration method '" + enumMethodUsedName + "' parameter " + parameterNum + ": " + ex.Message, ex); } var filterEvaluator = filter.ExprEvaluator; var expectedType = footprint.Parameters[parameterNum].ParamType; // Lambda-methods don't use a specific expected return-type, so passing null for type is fine. DotMethodUtil.ValidateSpecificType( enumMethodUsedName, DotMethodTypeEnum.ENUM, expectedType, null, filterEvaluator.ReturnType, parameterNum, filter); var numStreamsIncoming = validationContext.StreamTypeService.EventTypes.Length; return(new ExprDotEvalParamLambda( parameterNum, filter, filterEvaluator, numStreamsIncoming, goesNode.GoesToNames, additionalTypes)); }
public static ExprNodeUtilMethodDesc ResolveMethodAllowWildcardAndStream( string className, Type optionalClass, string methodName, IList<ExprNode> parameters, bool allowWildcard, EventType wildcardType, ExprNodeUtilResolveExceptionHandler exceptionHandler, string functionName, StatementRawInfo statementRawInfo, StatementCompileTimeServices services) { var paramTypes = new Type[parameters.Count]; var childForges = new ExprForge[parameters.Count]; var count = 0; var allowEventBeanType = new bool[parameters.Count]; var allowEventBeanCollType = new bool[parameters.Count]; var childEvalsEventBeanReturnTypesForges = new ExprForge[parameters.Count]; var allConstants = true; foreach (var childNode in parameters) { if (!EnumMethodResolver.IsEnumerationMethod(methodName, services.ImportServiceCompileTime) && childNode is ExprLambdaGoesNode) { throw new ExprValidationException( "Unrecognized lambda-expression encountered as parameter to UDF or static method '" + methodName + "'"); } if (childNode is ExprWildcard) { if (wildcardType == null || !allowWildcard) { throw new ExprValidationException("Failed to resolve wildcard parameter to a given event type"); } childForges[count] = new ExprEvalStreamNumUnd(0, wildcardType.UnderlyingType); childEvalsEventBeanReturnTypesForges[count] = new ExprEvalStreamNumEvent(0); paramTypes[count] = wildcardType.UnderlyingType; allowEventBeanType[count] = true; allConstants = false; count++; continue; } if (childNode is ExprStreamUnderlyingNode) { var und = (ExprStreamUnderlyingNode) childNode; var tableMetadata = services.TableCompileTimeResolver.ResolveTableFromEventType(und.EventType); if (tableMetadata == null) { childForges[count] = childNode.Forge; childEvalsEventBeanReturnTypesForges[count] = new ExprEvalStreamNumEvent(und.StreamId); } else { childForges[count] = new ExprEvalStreamTable( und.StreamId, und.EventType.UnderlyingType, tableMetadata); childEvalsEventBeanReturnTypesForges[count] = new ExprEvalStreamNumEventTable(und.StreamId, tableMetadata); } paramTypes[count] = childForges[count].EvaluationType; allowEventBeanType[count] = true; allConstants = false; count++; continue; } if (childNode.Forge is ExprEnumerationForge) { var enumeration = (ExprEnumerationForge) childNode.Forge; var eventType = enumeration.GetEventTypeSingle(statementRawInfo, services); childForges[count] = childNode.Forge; paramTypes[count] = childForges[count].EvaluationType; allConstants = false; if (eventType != null) { childEvalsEventBeanReturnTypesForges[count] = new ExprEvalStreamNumEnumSingleForge(enumeration); allowEventBeanType[count] = true; count++; continue; } var eventTypeColl = enumeration.GetEventTypeCollection(statementRawInfo, services); if (eventTypeColl != null) { childEvalsEventBeanReturnTypesForges[count] = new ExprEvalStreamNumEnumCollForge(enumeration); allowEventBeanCollType[count] = true; count++; continue; } } paramTypes[count] = childNode.Forge.EvaluationType; childForges[count] = childNode.Forge; count++; if (!childNode.Forge.ForgeConstantType.IsCompileTimeConstant) { allConstants = false; } } // Try to resolve the method MethodInfo method; try { if (optionalClass != null) { method = services.ImportServiceCompileTime.ResolveMethod( optionalClass, methodName, paramTypes, allowEventBeanType); } else { method = services.ImportServiceCompileTime.ResolveMethodOverloadChecked( className, methodName, paramTypes, allowEventBeanType, allowEventBeanCollType, services.ClassProvidedExtension); } } catch (Exception e) { throw exceptionHandler.Handle(e); } var parameterTypes = method.GetParameterTypes(); // rewrite those evaluator that should return the event itself if (CollectionUtil.IsAnySet(allowEventBeanType)) { for (var i = 0; i < parameters.Count; i++) { if (allowEventBeanType[i] && parameterTypes[i] == typeof(EventBean)) { childForges[i] = childEvalsEventBeanReturnTypesForges[i]; } } } // rewrite those evaluators that should return the event collection if (CollectionUtil.IsAnySet(allowEventBeanCollType)) { for (var i = 0; i < parameters.Count; i++) { if (allowEventBeanCollType[i] && (parameterTypes[i] == typeof(ICollection<EventBean>))) { childForges[i] = childEvalsEventBeanReturnTypesForges[i]; } } } // add an evaluator if the method expects a context object if (!method.IsVarArgs() && parameterTypes.Length > 0 && parameterTypes[parameterTypes.Length - 1] == typeof(EPLMethodInvocationContext)) { var node = new ExprEvalMethodContext(functionName); childForges = (ExprForge[]) CollectionUtil.ArrayExpandAddSingle(childForges, node); } // handle varargs if (method.IsVarArgs()) { // handle context parameter var numMethodParams = parameterTypes.Length; if (numMethodParams > 1 && parameterTypes[numMethodParams - 2] == typeof(EPLMethodInvocationContext)) { var rewrittenForges = new ExprForge[childForges.Length + 1]; Array.Copy(childForges, 0, rewrittenForges, 0, numMethodParams - 2); rewrittenForges[numMethodParams - 2] = new ExprEvalMethodContext(functionName); Array.Copy( childForges, numMethodParams - 2, rewrittenForges, numMethodParams - 1, childForges.Length - (numMethodParams - 2)); childForges = rewrittenForges; } childForges = ExprNodeUtilityMake.MakeVarargArrayForges(method, childForges); } var localInlinedClass = services.ClassProvidedExtension.IsLocalInlinedClass(method.DeclaringType); return new ExprNodeUtilMethodDesc(allConstants, childForges, method, localInlinedClass); }
/// <summary> /// Gets Recipient Type/Database from Exchange database, this method can be more general, but it is ok /// for out needs /// </summary> /// <param name="oc">object class, currently the moethod works for <see cref="ObjectClass.ACCOUNT"/> only</param> /// <param name="cobject">connector object to get the recipient type/database for</param> /// <param name="attToGet">attributes to get</param> /// <returns>Connector Object with recipient type added</returns> /// <exception cref="ConnectorException">In case of some troubles in powershell (if the /// user is not found we get this exception too)</exception> private ConnectorObject AddExchangeAttributes(ObjectClass oc, ConnectorObject cobject, IEnumerable <string> attToGet) { ExchangeUtility.NullCheck(oc, "name", this.configuration); ExchangeUtility.NullCheck(oc, "cobject", this.configuration); // we support ACCOUNT only or there is nothing to add if (!oc.Is(ObjectClass.ACCOUNT_NAME) || attToGet == null) { return(cobject); } // check it is not deleted object bool?deleted = ExchangeUtility.GetAttValue(AttIsDeleted, cobject.GetAttributes()) as bool?; if (deleted != null && deleted == true) { // do nothing, it is deleted object return(cobject); } ICollection <string> lattToGet = CollectionUtil.NewCaseInsensitiveSet(); CollectionUtil.AddAll(lattToGet, attToGet); foreach (string att in attToGet) { if (cobject.GetAttributeByName(att) != null && att != AttDatabase) { lattToGet.Remove(att); } } if (lattToGet.Count == 0) { return(cobject); } ConnectorObjectBuilder cobjBuilder = new ConnectorObjectBuilder(); cobjBuilder.AddAttributes(cobject.GetAttributes()); PSExchangeConnector.CommandInfo cmdInfo = PSExchangeConnector.CommandInfo.GetUser; // prepare the connector attribute list to get the command ICollection <ConnectorAttribute> attributes = new Collection <ConnectorAttribute> { cobject.Name }; // get the command Command cmd = ExchangeUtility.GetCommand(cmdInfo, attributes, this.configuration); ICollection <PSObject> foundObjects = this.InvokePipeline(cmd); PSObject user = null; if (foundObjects != null && foundObjects.Count == 1) { user = GetFirstElement(foundObjects); foreach (var info in user.Properties) { ConnectorAttribute att = GetAsAttribute(info); if (att != null && lattToGet.Contains(att.Name)) { cobjBuilder.AddAttribute(att); lattToGet.Remove(att.Name); } } if (lattToGet.Count == 0) { return(cobjBuilder.Build()); } } if (user == null) { // nothing to do return(cobject); } string rcptType = user.Members[AttRecipientType].Value.ToString(); foundObjects = null; // get detailed information if (rcptType == RcptTypeMailBox) { foundObjects = this.InvokePipeline(ExchangeUtility.GetCommand(PSExchangeConnector.CommandInfo.GetMailbox, attributes, this.configuration)); } else if (rcptType == RcptTypeMailUser) { foundObjects = this.InvokePipeline(ExchangeUtility.GetCommand(PSExchangeConnector.CommandInfo.GetMailUser, attributes, this.configuration)); } if (foundObjects != null && foundObjects.Count == 1) { PSObject userDetails = GetFirstElement(foundObjects); foreach (var info in userDetails.Properties) { ConnectorAttribute att = GetAsAttribute(info); if (att != null && lattToGet.Contains(att.Name)) { cobjBuilder.AddAttribute(att); lattToGet.Remove(att.Name); } } } return(cobjBuilder.Build()); }
public virtual void AddChildNode(ExprNode childNode) { ChildNodes = (ExprNode[]) CollectionUtil.ArrayExpandAddSingle(ChildNodes, childNode); }