public static List <byte[]> GetDataArrayValueFromPList(PNode rootNode, string key) { if (rootNode is DictionaryNode) { PNode value; if (((DictionaryNode)rootNode).TryGetValue(key, out value)) { if (value is ArrayNode) { ArrayNode array = (ArrayNode)value; List <byte[]> result = new List <byte[]>(); foreach (PNode node in array) { DataNode dataNode = node as DataNode; if (dataNode != null) { result.Add(dataNode.Value); } } return(result); } } } return(null); }
//ARRAYS// public string Visit(ArrayNode node) { int counterone = 0; var sb = new StringBuilder(); ArrayList theInts = new ArrayList(); foreach (var n in node) { theInts.Add(Visit((dynamic)n)); } foreach (var x in theInts) { counterone++; } sb.Append("\t\tldc.i4 " + 0 + "\n"); sb.Append(String.Format("\t\tcall int32 class ['deeplingolib']'DeepLingo'.'Utils'::'New'(int32)\n\n")); for (int i = 0; i < counterone; i++) { sb.Append("\t\tdup\n"); } foreach (var x in theInts) { sb.Append(x); sb.Append(String.Format("\t\tcall int32 class ['deeplingolib']'DeepLingo'.'Utils'::'Add'(int32,int32)\n\n")); sb.Append("\t\tpop\n"); } return(sb.ToString()); }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test public void shouldHavePredefinedRoles() throws Exception //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: public virtual void ShouldHavePredefinedRoles() { // Given StartServerWithConfiguredUser(); // When string method = "POST"; string path = "db/data/transaction/commit"; HTTP.RawPayload payload = HTTP.RawPayload.quotedJson("{'statements':[{'statement':'CALL dbms.security.listRoles()'}]}"); HTTP.Response response = HTTP.withBasicAuth("neo4j", "secret").request(method, Server.baseUri().resolve(path).ToString(), payload); // Then assertThat(response.Status(), equalTo(200)); ArrayNode errors = ( ArrayNode )response.Get("errors"); assertThat("Should have no errors", errors.size(), equalTo(0)); ArrayNode results = ( ArrayNode )response.Get("results"); ArrayNode data = ( ArrayNode )results.get(0).get("data"); assertThat("Should have 5 predefined roles", data.size(), equalTo(5)); Stream <string> values = data.findValues("row").Select(row => row.get(0).asText()); assertThat("Expected specific roles", values.collect(Collectors.toList()), hasItems("admin", "architect", "publisher", "editor", "reader")); }
public override void VisitArrayNode(ArrayNode node) { node.Type.Visit(this); var initializer = InitializerExpression(SyntaxKind.ArrayInitializerExpression); foreach (var element in node.Elements) { element.Expression.Visit(this); initializer = initializer.AddExpressions(expressions.Pop()); } var arrayType = ArrayType(expressions.Pop() as TypeSyntax); var rankSpecifier = ArrayRankSpecifier().AddSizes(OmittedArraySizeExpression()); var array = ArrayCreationExpression(arrayType) .AddTypeRankSpecifiers(rankSpecifier) .WithInitializer(initializer); var libraryArray = ObjectCreationExpression( GenericName("Array").AddTypeArgumentListArguments(arrayType) ).AddArgumentListArguments(Argument(array)); libraryArray = GetNodeWithAnnotation(libraryArray, node.Location) as ObjectCreationExpressionSyntax; expressions.Push(libraryArray); }
//check if it is array type public override void Visit(ArrayNode node) { base.Visit(node); var typeOfArray = node.VariableType; if (typeOfArray == null) { throw new TypeCheckException("No set Type for Array."); } if (!(typeOfArray is ArrayTypeNode)) { throw new TypeCheckException("Array doesn't have array type"); } var typeOfElementInArray = ((ArrayTypeNode)typeOfArray).ElementType; if (typeOfElementInArray == null) { throw new TypeCheckException("Type of element in array is not set."); } foreach (var expression in node.Elements) { if (expression.ExpressionType == null) { throw new TypeCheckException("Array contains value with not specified type."); } if (!typeOfElementInArray.Equals(expression.ExpressionType)) { throw new TypeCheckException("Improper Type of element in array."); } } node.ExpressionType = node.VariableType; }
public void Equals_returns_true_for_instances_with_null_and_empty_children() { var sets1 = new ArrayNode("Name", null); var sets2 = new ArrayNode("Name", new ISettingsNode[0]); Equals(sets1, sets2).Should().BeTrue(); }
internal UnboundedBufferManager(int capacityHint) { var n = new ArrayNode(capacityHint); this.tail = n; this.head = n; }
public static TSource SingleOrDefault <TSource>(this TSource[] source, Func <TSource, bool> predicate) { var aggregate = new SingleOrDefaultPredicate <TSource>(predicate); ArrayNode.ProcessArray(source, ref aggregate); return(aggregate.GetResult()); }
public static System.Linq.ILookup <TKey, TElement> ToLookup <TSource, TKey, TElement>(this TSource[] source, Func <TSource, TKey> keySelector, Func <TSource, TElement> elementSelector, IEqualityComparer <TKey> comparer = null) { var aggregate = new ToLookup <TSource, TKey, TElement>(comparer, keySelector, elementSelector); ArrayNode.ProcessArray(source, ref aggregate); return(aggregate.GetResult()); }
public static bool Contains <TSource>(this TSource[] source, TSource value, IEqualityComparer <TSource> comparer) { var aggregate = new ContainsByComparer <TSource>(comparer, value); ArrayNode.ProcessArray(source, ref aggregate); return(aggregate.GetResult()); }
public static TSource Single <TSource>(this TSource[] source) { var aggregate = new Single <TSource>(); ArrayNode.ProcessArray(source, ref aggregate); return(aggregate.GetResult()); }
public static int Count <TSource>(this TSource[] source, Func <TSource, bool> predicate) { var aggregate = new CountIf <TSource>(predicate); ArrayNode.ProcessArray(source, ref aggregate); return(aggregate.GetResult()); }
public static bool All <TSource>(this TSource[] source, Func <TSource, bool> predicate) { var aggregate = new All <TSource, FuncToIFunc <TSource, bool> >(new FuncToIFunc <TSource, bool>(predicate)); ArrayNode.ProcessArray(source, ref aggregate); return(aggregate.GetResult()); }
public static TResult Aggregate <TSource, TAccumulate, TResult>(this TSource[] source, TAccumulate seed, Func <TAccumulate, TSource, TAccumulate> func, Func <TAccumulate, TResult> resultSelector) { var aggregate = new FoldForward <TSource, TAccumulate>(func, seed); ArrayNode.ProcessArray(source, ref aggregate); return(resultSelector(aggregate.GetResult())); }
public static List <string> GetStringArrayValueFromPList(PNode rootNode, string key) { if (rootNode is DictionaryNode) { PNode value; if (((DictionaryNode)rootNode).TryGetValue(key, out value)) { if (value is ArrayNode) { ArrayNode array = (ArrayNode)value; List <string> result = new List <string>(); foreach (PNode node in array) { StringNode stringNode = node as StringNode; if (stringNode != null) { result.Add(stringNode.Value); } } return(result); } } } return(null); }
public static Dictionary <TKey, TSource> ToDictionary <TSource, TKey>(this TSource[] source, Func <TSource, TKey> keySelector, IEqualityComparer <TKey> comparer = null) { var aggregate = new ToDictionary <TSource, TKey>(keySelector, comparer); ArrayNode.ProcessArray(source, ref aggregate); return(aggregate.GetResult()); }
public static TSource Aggregate <TSource>(this TSource[] source, Func <TSource, TSource, TSource> func) { var aggregate = new ReduceForward <TSource>(func); ArrayNode.ProcessArray(source, ref aggregate); return(aggregate.GetResult()); }
protected override PropertyEditor AutoCreateMemberEditor(MemberInfo info) { if (ReflectionHelper.MemberInfoEquals(info, typeof(ArrayNode).GetProperty("PrimitiveData"))) { ArrayNode arrayNode = this.GetValue().NotNull().FirstOrDefault() as ArrayNode; Type actualType = ReflectionHelper.ResolveType(arrayNode.TypeString); if (actualType == null || !actualType.IsArray || actualType.GetElementType() == null) { actualType = (info as PropertyInfo).PropertyType; } bool primitiveDataEditable = actualType != null && actualType.IsArray && (actualType.GetElementType().IsPrimitive || actualType.GetElementType() == typeof(string)); this.editorPrimitiveData = this.ParentGrid.CreateEditor(actualType, this); if (!primitiveDataEditable) { this.editorPrimitiveData.Setter = null; } return(this.editorPrimitiveData); } else { return(base.AutoCreateMemberEditor(info)); } }
public override String ToString() { StringBuilder str = new StringBuilder().Append('{'); int size = list.Size(), i = 0; ArrayNode <Object> o = this.list.Node().next; for (; o != this.list.Node();) { if (o.data is String) { str.Append('"').Append(o.data).Append('"'); } else { str.Append(o.data); } if (++i < size) { str.Append(','); } o = o.next; } str.Append('}'); return(str.ToString()); }
/// <inheritdoc/> public override (Node Head, Node Tail) Insert(Int32 index, Char[] element) { Node head; Node tail; if (index == 0) { tail = this; head = new ArrayNode(element, previous: null, next: tail); tail.Previous = head; } else if (index == Count) { head = this; tail = new ArrayNode(element, previous: head, next: null); head.Next = tail; } else { head = Slice(0, index); tail = Slice(index, Count - index); Node mid = new ArrayNode(element, previous: head, next: tail); head.Next = mid; tail.Previous = mid; } return(head, tail); }
public static HashSet <TSource> ToHashSet <TSource>(this TSource[] source, IEqualityComparer <TSource> comparer = null) { var aggregate = new ToHashSet <TSource>(comparer); ArrayNode.ProcessArray(source, ref aggregate); return(aggregate.GetResult()); }
public ArrayList GetArrayList(ArrayNode arrayNode) { ArrayList arrayList = new ArrayList(); foreach (var item in arrayNode.Values) { if (item is ListKeyValueNode) { // has key, value var listKeyvalueNodeParser = new ListKeyValueNodeParser(); var listKeyvalueNode = listKeyvalueNodeParser.GetDictionary(item as ListKeyValueNode); arrayList.Add(listKeyvalueNode); } else if (item is ArrayNode) { var arrayNodeParser = new ArrayNodeParser(); var innerArrayList = arrayNodeParser.GetArrayList(item as ArrayNode); arrayList.Add(innerArrayList); } else if (item is ValueNode) { var ValueNodeParser = new ValueNodeParser(); var value = ValueNodeParser.GetDictionaryValue(item as ValueNode); arrayList.Add(value); } else { throw new Exception(); } } return(arrayList); }
private ArrayNode ParseArray() { Expect(TokenType.LBRACK); Next(); var array = new ArrayNode(Position(-1)); while (More() && !Accept(TokenType.RBRACK)) { array.AddDefaultElement(ParseExpression()); if (Accept(TokenType.COMMA)) { Next(); ExpectNot(TokenType.RBRACK); } else { Expect(TokenType.RBRACK); } } Expect(TokenType.RBRACK); Next(); return(array); }
// Token: 0x06000033 RID: 51 RVA: 0x00002D68 File Offset: 0x00000F68 private static int GetNodeCount(PNode node) { if (node == null) { throw new ArgumentNullException("node"); } ArrayNode arrayNode = node as ArrayNode; if (arrayNode != null) { int num = 1; foreach (PNode node2 in arrayNode) { num += BinaryFormatWriter.GetNodeCount(node2); } return(num); } DictionaryNode dictionaryNode = node as DictionaryNode; if (dictionaryNode != null) { int num2 = 1; foreach (PNode node3 in dictionaryNode.Values) { num2 += BinaryFormatWriter.GetNodeCount(node3); } num2 += dictionaryNode.Keys.Count; return(num2); } return(1); }
/// <summary> /// Transforms the given node into some other node if necessary. /// </summary> /// <param name="node">The node to transform.</param> /// <returns>The transformed node.</returns> private static BaseNode TransformNode(BaseNode node) { var custom = GetCustomCodeGeneratorForNode(node); if (custom != null) { return(custom.TransformNode(node)); } BaseNode GetCharacterNodeForEncoding(Encoding encoding) { if (encoding.IsSameCodePage(Encoding.Unicode)) { return(new Utf16CharacterNode()); } if (encoding.IsSameCodePage(Encoding.UTF32)) { return(new Utf32CharacterNode()); } return(new Utf8CharacterNode()); } if (node is BaseTextNode textNode) { var arrayNode = new ArrayNode { Count = textNode.Length }; arrayNode.CopyFromNode(node); arrayNode.ChangeInnerNode(GetCharacterNodeForEncoding(textNode.Encoding)); return(arrayNode); } if (node is BaseTextPtrNode textPtrNode) { var pointerNode = new PointerNode(); pointerNode.CopyFromNode(node); pointerNode.ChangeInnerNode(GetCharacterNodeForEncoding(textPtrNode.Encoding)); return(pointerNode); } if (node is BitFieldNode bitFieldNode) { var underlayingNode = bitFieldNode.GetUnderlayingNode(); underlayingNode.CopyFromNode(node); return(underlayingNode); } if (node is BaseHexNode hexNode) { var arrayNode = new ArrayNode { Count = hexNode.MemorySize }; arrayNode.CopyFromNode(node); arrayNode.ChangeInnerNode(new Utf8CharacterNode()); return(arrayNode); } return(node); }
public void LoadArrayNode(ArrayNode node, NewNode currentNode, int counter) { var key = node.Index; if (currentNode == null) { currentNode = new NewNode(); FlattenedNodes.Add(currentNode); } currentNode.AddKeyNode(node, "[" + key + "]"); foreach (var nodeValue in node.Values) { if (currentNode.HasValueNode) { var nodes = currentNode.GetNodes(); var currentNode2 = new NewNode(); foreach (var n in nodes.Take(counter)) { currentNode2.AddKeyNode(n.Key, n.Value); } currentNode2.AddKeyNode(node, "[" + key + "]"); FlattenedNodes.Add(currentNode2); currentNode = currentNode2; } if (nodeValue is ArrayNode) { var arrayNode = nodeValue as ArrayNode; LoadArrayNode(arrayNode, currentNode, counter + 1); } else if (nodeValue is KeyArrayNode) { var keyArrayNode = nodeValue as KeyArrayNode; LoadKeyArrayNode(keyArrayNode, currentNode, counter + 1); } else if (nodeValue is KeyValueNode) { var keyValueNode = nodeValue as KeyValueNode; LoadKeyValueNode(keyValueNode, currentNode, counter + 1); } else if (nodeValue is ListKeyValueNode) { var listKeyValueNode = nodeValue as ListKeyValueNode; LoadListKeyValueNode(listKeyValueNode, currentNode, counter + 1); } else if (nodeValue is ValueNode) { var valueNode = nodeValue as ValueNode; LoadValueNode(valueNode, currentNode); } else if (nodeValue == null) { var valueNode = new ValueNode(); valueNode.Value = ""; currentNode.SetValueNode(valueNode); } } }
public void ForeachForEmptyElemsTest() { var n = new ArrayNode(); foreach (var e in n) { } }
public void DeletionForEmptyElemsTest() { var n = new ArrayNode(); n.RemoveElementAt(0); Assert.AreEqual(null, n.Elems); }
/// <summary> /// 构造一个数组节点。 /// </summary> /// <param name="nodes">所有数组中的项。</param> /// <returns></returns> public IArray Array(IEnumerable <IQueryNode> nodes) { IArray array = new ArrayNode(); array.Items = new List <IQueryNode>(nodes); return(array); }
private IReq <ArrayNode> Array(Token lbrac) { var value = this.ArrayValue(out var emptyArrayComments); return(this.input.Expect(t => t.Type == TokenType.RBrac) .CreateNode( onSuccess: rbrac => ArrayNode.Create(lbrac, value, rbrac, emptyArrayComments, this.AppComment()).Req(), onError: ue => SyntaxErrorNode.Unexpected("Expected array close tag ']'", ue))); }
public ArrayNameNode() { ArrayDimensions = null; }
public ArrayNode(ArrayNode rhs) : base(rhs) { Expr = null; Type = null; if (null != rhs) { if (null != rhs.Expr) { Expr = ProtoCore.Utils.NodeUtils.Clone(rhs.Expr); } if (null != rhs.Type) { Type = ProtoCore.Utils.NodeUtils.Clone(rhs.Type); } } }
public ArrayNameNode(ArrayNameNode rhs) : base(rhs) { ArrayDimensions = null; if (null != rhs.ArrayDimensions) { ArrayDimensions = new ArrayNode(rhs.ArrayDimensions); } }
private static void GenerateArray(ArrayNode node, DataContext data) { Append(data, "new dynamic[{0}] {{ ", node.ValueExpressions.Count); for (int i = 0; i < node.ValueExpressions.Count; i++) { if (i != 0) Append(data, ", "); GenerateExpression(node.ValueExpressions[i], data); } Append(data, " }}"); }