Esempio n. 1
0
        public override Node VisitRecord([NotNull] TigerParser.RecordContext context)
        {
            var node = new RecordNode(context);

            var typeId = new IdNode(context, context.typeID.Text);

            node.Children.Add(typeId); // RECORD TYPE

            ITerminalNode[]           ids   = context.ID();
            TigerParser.ExprContext[] exprs = context.expr();

            for (int i = 1; i < ids.Length; i++)
            {
                var fieldId = new IdNode(
                    ids[i].Symbol.Line,
                    ids[i].Symbol.Column,
                    ids[i].GetText());

                var fieldExpr = Visit(exprs[i - 1]);

                var field = new FieldNode(fieldId.Line, fieldId.Column);
                field.Children.Add(fieldId);   // field -> FIELD NAME
                field.Children.Add(fieldExpr); // field -> FIELD EXPRESSION

                node.Children.Add(field);      // FIELD #i
            }
            return(node);
        }
Esempio n. 2
0
        private void VerifyEncodeDecode(List <EsfNode> nodes)
        {
            RecordNode rootNode = CreateRootNode();

            rootNode.Value = nodes;
            // EsfFile encodedFile = new EsfFile(rootNode, codec);
            MemoryStream stream = new MemoryStream();

            byte[] encoded;
            using (BinaryWriter writer = new BinaryWriter(stream)) {
                codec.EncodeRootNode(writer, rootNode);
                encoded = stream.ToArray();
            }
            EsfNode decoded;

            using (BinaryReader reader = new BinaryReader(new MemoryStream(encoded))) {
                decoded = codec.Parse(reader);
            }
            assertEqual(rootNode, decoded);
            // EsfNode decodedResult = (decoded as ParentNode).AllNodes[0];
            for (int i = 0; i < rootNode.AllNodes.Count; i++)
            {
                assertEqual(rootNode.AllNodes[i], (decoded as ParentNode).AllNodes[i]);
            }
//            nodes.ForEach(node => {assertEqual(node, decodedResult); });
        }
Esempio n. 3
0
    public void GenerateNewNode(Record record)
    {
        GameObject newNode = Instantiate(nodeObj);

        newNode.transform.SetParent(content.transform);
        RecordNode newrecordNode = newNode.GetComponent <RecordNode> ();

        newrecordNode.Initialize(record, CalcHeight(record.GetRunk()));
    }
Esempio n. 4
0
 public void AddConverterToRecord(string converterName)
 {
     currentConverterRecord = converterRecords.FirstOrDefault(converter => converter.Name == converterName);
     if (currentConverterRecord != null)
     {
         return;
     }
     currentConverterRecord = new RecordNode(converterName, "");
     converterRecords.Add(currentConverterRecord);
 }
Esempio n. 5
0
        public void TestRecordNode()
        {
            RecordNode node = new RecordNode(codec, (byte)EsfType.RECORD)
            {
                Name  = "test",
                Value = createSomeNodes()
            };

            VerifyEncodeDecode(node);
        }
Esempio n. 6
0
 public int Recording(int seq, HumanBodyBones bone, Transform transfrom)
 {
     if (seq > RecordSkipSeq)
     {
         if (!records.ContainsKey(seq))
         {
             records[seq] = new List <RecordNode>();
         }
         RecordNode node = new RecordNode(bone, transfrom.position, transfrom.rotation);
         records[seq].Add(node);
     }
     return(records.Keys.Count);
 }
Esempio n. 7
0
        public static void Main(string[] args)
        {
            AbcaFileCodec codec = new AbcaFileCodec
            {
                Header = new EsfHeader
                {
                    ID = 0xABCA
                }
            };
            RecordNode root = new RecordNode(codec)
            {
                Name = "root"
            };
            RecordNode child = new RecordNode(codec)
            {
                Name = "copySource"
            };
            EsfValueNode <string> utf16String = (EsfValueNode <string>)codec.CreateValueNode(EsfType.UTF16);

            utf16String.Value = "utf16";
            child.Value.Add(utf16String);
            root.Value.Add(child);
            child = new RecordNode(codec)
            {
                Name = "copyTarget"
            };
            EsfValueNode <string> copyString = (EsfValueNode <string>)utf16String.CreateCopy();

            // copyString.Value = "copy";
            copyString.FromString("copy");
            child.Value.Add(copyString);
            root.Value.Add(child);

            // this is needed for the file to create the record nodes properly
            SortedList <int, string> nodeNames = new SortedList <int, string>();

            nodeNames.Add(0, "root");
            nodeNames.Add(1, "copySource");
            nodeNames.Add(2, "copyTarget");
            // this property needs to be added to the EsfFileCodec, getting and setting EsfFileCodec#nodeNames
            codec.NodeNames = nodeNames;

            EsfFile file = new EsfFile(root, codec);

            EsfCodecUtil.WriteEsfFile("string_container.esf", file);
        }
Esempio n. 8
0
            // 1.
            // <CallNode>
            //    |
            //  <ListNode>
            //    |
            //  <Error RecordNode>[Cursor position]

            // For example, Patch(Accounts, OldRecord, UpdateRecord, {<Cursor position>

            // 2.
            // <CallNode>
            //    |
            //  <ListNode>
            //    |
            //  <RecordNode>
            //    |
            //  <Error Node>[Cursor position]

            // For example, Patch(Accounts, OldRecord, UpdateRecord, {A:"",<cursor position>})

            // 3.
            // <CallNode>
            //    |
            //  <ListNode>
            //    |
            //  <VariadicOpNode>
            //    |
            //  <RecordNode>
            //    |
            //  <Error Identifier Node> [Cursor position]
            // For example, Patch(Accounts, OldRecord, UpdateRecord, { 'Account Name': ""});
            //              Patch(Accounts, OldRecord, UpdateRecord,{<Cursor position>);
            private static bool TryGetRecordNodeWithinACallNode(TexlNode node, out RecordNode recordNode, out CallNode callNode)
            {
                Contracts.AssertValue(node);

                if (!TryGetParentRecordNode(node, out recordNode) || !TryGetParentListNode(recordNode, out ListNode listNode))
                {
                    callNode = null;
                    return(false);
                }

                if (!(listNode.Parent is CallNode cNode))
                {
                    callNode = null;
                    return(false);
                }

                callNode = cNode;
                return(true);
            }
Esempio n. 9
0
        public void TestEquals()
        {
            EsfNode valueNode = new IntNode {
                Value = 1
            };
            EsfNode valueNode2 = new IntNode {
                Value = 1
            };

            assertEqual(valueNode, valueNode2);

            List <EsfNode> nodeList1 = new List <EsfNode>();

            nodeList1.Add(valueNode);
            List <EsfNode> nodeList2 = new List <EsfNode>();

            nodeList2.Add(valueNode);
            RecordNode node = new RecordNode(null)
            {
                Name = "name", Value = nodeList1
            };
            EsfNode node2 = new RecordNode(null)
            {
                Name = "nodename", Value = nodeList2
            };

            assertNotEqual(node, node2);
            node = new RecordNode(null)
            {
                Name = "nodename", Value = nodeList1
            };
            assertEqual(node, node2);

            AbcaFileCodec codec  = new AbcaFileCodec();
            EsfFile       file   = new EsfFile(node, codec);
            AbceCodec     codec2 = new AbceCodec();
            EsfFile       file2  = new EsfFile(node2, codec2);

            assertNotEqual(file, file2);
            file2.Codec = codec;
            assertEqual(file, file2);
        }
Esempio n. 10
0
            private static bool TryGetParentRecordNode(TexlNode node, out RecordNode recordNode)
            {
                Contracts.AssertValue(node);

                TexlNode parentNode = node;

                while (parentNode != null)
                {
                    if (parentNode.Kind == NodeKind.Record)
                    {
                        recordNode = parentNode.AsRecord();
                        return(true);
                    }

                    parentNode = parentNode.Parent;
                }

                recordNode = null;
                return(false);
            }
Esempio n. 11
0
        private void CollectInnerType(RecordNode node, PackageType packageType)
        {
            var record = new RecordType(packageType.Name, node.Name);

            foreach (var item in node.Vars)
            {
                var varInfo = GetVar(item);

                record.AddField(varInfo.Name, varInfo.Type);
            }

            bool ok = packageType.AddType(record);

            types.AddType(record);

            if (!ok)
            {
                Log(String.Format("Запись с именем {0} уже существует", node.Name), node);
            }
        }
Esempio n. 12
0
            private static bool TryGetParentListNode(RecordNode node, out ListNode listNode)
            {
                Contracts.AssertValue(node);

                TexlNode parentNode = node;

                while (parentNode != null)
                {
                    if (parentNode.Kind == NodeKind.List)
                    {
                        listNode = parentNode.AsList();
                        return(true);
                    }

                    parentNode = parentNode.Parent;
                }

                listNode = null;
                return(false);
            }
Esempio n. 13
0
        static void Main(string[] args)
        {
            var writer = new StringWriter();

            using var digraph = new DigraphWriter("sample", new StreamWriter("G:\\output.dot"));

            var a = new RecordNode(Direction.Horizontal);

            a.RootLabel.Add("a");
            a.RootLabel.Add("b");


            var b = new RecordNode(Direction.Vertical);

            b.RootLabel.Add("c");
            b.RootLabel.Add("d");

            digraph.WriteEdge(a, b);
            digraph.WriteRecord(a);
            digraph.WriteRecord(b);
        }
Esempio n. 14
0
        public override bool PreVisit(RecordNode node)
        {
            Contracts.AssertValue(node);
            Contracts.Assert(node.Token.Kind == TokKind.CurlyOpen || node.Token.Kind == TokKind.Ident);

            if (_cursorPosition <= node.Token.Span.Min || // If cursor position is before the open curly return the record node.
                node.Count == 0 ||  // Or if the record node is empty, return the record node.
                (node.CurlyClose != null && node.CurlyClose.Span.Lim <= _cursorPosition))    // Cursor is after the closed curly.
            {
                _result = node;
                return(false);
            }

            // Cursor is between the open and closed curly.
            int length = CollectionUtils.Size(node.Commas);

            for (int i = 0; i < length; i++)
            {
                Token tokComma = node.Commas[i];

                // Cursor position is inside ith child.
                if (_cursorPosition <= tokComma.Span.Min)
                {
                    node.Children[i].Accept(this);
                    return(false);
                }
            }

            if (node.CurlyClose == null || _cursorPosition <= node.CurlyClose.Span.Min)
            {
                // Cursor is within the last child.
                node.Children[node.Children.Length - 1].Accept(this);
                return(false);
            }

            // Cursor is after the closing curly.
            _result = node;
            return(false);
        }
Esempio n. 15
0
        public void TestOptimizedIntNode()
        {
            OptimizedIntNode optimized = new OptimizedIntNode {
                Codec = codec, Value = 5
            };
            OptimizedIntNode other = new OptimizedIntNode {
                Codec = codec, Value = 5
            };

            assertEqual(optimized, other);

            RecordNode rootNode = CreateRootNode();

            rootNode.Value = new List <EsfNode>(new EsfNode[] { other });
            //rootNode.AllNodes.Add(other);
            other.FromString("1");
            assertTrue(other.Modified);
            assertTrue(rootNode.Modified);
            assertEqual(other.Value, 1);

            //assertEqual(optimized, other);
        }
Esempio n. 16
0
 public override Result Visit(RecordNode node, Context context)
 {
     return(Aggregate(node.Children.Select(child => child.Accept(this, context))));
 }
Esempio n. 17
0
 private void Visit(RecordNode node, TypeInfo type)
 {
 }
Esempio n. 18
0
 public abstract Result Visit(RecordNode node, Context context);
Esempio n. 19
0
 public virtual bool PreVisit(RecordNode node)
 {
     return(true);
 }
Esempio n. 20
0
 public abstract void PostVisit(RecordNode node);