Ejemplo n.º 1
0
 /*
  * clones the entire chain
  */
 public CH_closedScope(IEnumerable <Ref> items)
 {
     foreach (var itm in items)
     {
         LL_head = LL_head.chain(itm.name, itm.CH);
     }
 }
Ejemplo n.º 2
0
        public static T findPay <T> (this LL <T> node_in, string search_name) => node_in.findNode(search_name).pay;     // todo remove

        public static IEnumerable <LL <T> > LIFO <T>  (this LL <T> node_in)
        {
            for (var node = node_in; node != null; node = node.prev)
            {
                yield return(node);
            }
        }
Ejemplo n.º 3
0
        public static void Test1_basic_LL_tests()
        {
            LL <int> empty_int = null;

            foreach (var node in empty_int.chain("foo", 3).chain("bar", 4).LIFO())
            {
                Console.WriteLine(node.name + " " + node.pay);                                                                                 // mainly to test chaining from null
            }
            // hmm thats neat :)
            // also single assignment. empty int is still null

            D.Assert(empty_int.LIFO().ToArray().SequenceEqual(new LL <int> [0]));
            D.Assert(empty_int.LIFO_shadowed().ToArray().SequenceEqual(new LL <int> [0]));
            AUX.AssertThrows <LL_Exception> (() => empty_int.findPay("any key -- the LL is empty "));

            var zing = ((LL <string>)null).
                       chain("v1", "val1").
                       chain("v2", "boioioioioiing").
                       chain("v1", "shadowed");

            foreach (var node in zing.LIFO_shadowed())
            {
                Console.WriteLine(node.name + " " + node.pay);
            }

            AUX.AssertThrows <LL_Exception> (() => zing.findNode("non present key"));

            Console.WriteLine("================= LL ok ============= ");
        }
Ejemplo n.º 4
0
 preCH_deltaScope(CH_closedScope origScope, LL <preCH> origLL, LL <preCH> own, LL <preCH> extnls)
 {
     D.Assert(origScope != null);
     this.origScope = origScope;
     origLL_head    = origLL;
     ownLL_head     = own;
     externals      = extnls;
 } // the readonlys need a detour over constructor
Ejemplo n.º 5
0
 public preCH_deltaScope(CH_closedScope clSC)
 {
     D.Assert(clSC != null);
     origScope = clSC;
     foreach (var nodeCH in clSC.LL_head.LIFO_shadowed().Reverse())
     {
         origLL_head = origLL_head.chain(nodeCH.name, new adapter_preCH(nodeCH.pay));
     }
 }
Ejemplo n.º 6
0
 public CH_deltaScope(CH_closedScope clsSc, LL <TypedCH> ll, LL <TypedCH> externals)
 {
     if (clsSc == null)
     {
         throw new ScopeException("origin scope can't be null");
     }
     orig_scope      = clsSc;
     this.ownLL_head = ll;
     this.externals  = externals;
 }
Ejemplo n.º 7
0
        public static IEnumerable <LL <T> > LIFO_shadowed <T> (this LL <T> node_in)
        {
            var seen = new HashSet <string>();

            foreach (var node in node_in.LIFO())
            {
                if (!seen.Contains(node.name))
                {
                    seen.Add(node.name);
                    yield return(node);
                }
            }
        }
Ejemplo n.º 8
0
        public static LL <T> findNode <T> (this LL <T> node_in, string search_name)
        {
            LL <T> node = node_in;

            while (true)
            {
                if (node == null)
                {
                    throw new LL_Exception();
                }
                if (search_name == node.name)
                {
                    return(node);
                }
                node = node.prev;
            }
        }
Ejemplo n.º 9
0
        public CH_deltaScope instantiate()             // resolves all preCHs , triggers their instantiation to proper CHs
        // using the decl interface is too headscratchy, becuase the original order between decls and refs (not within them) would have to be reconstructed ( self shadowing )
        {
            LL <TypedCH> CHdelt_own = null;

            foreach (var n in ownLL_head.LIFO().Reverse())
            {
                CHdelt_own = CHdelt_own.chain(n.name, n.pay.CH);
            }

            LL <TypedCH> CHdelt_externals = null;

            foreach (var n in externals.LIFO().Reverse())
            {
                CHdelt_externals = CHdelt_externals.chain(n.name, n.pay.CH);
            }
            return(new CH_deltaScope(origScope, CHdelt_own, CHdelt_externals));
        }
Ejemplo n.º 10
0
 public static Ref LL2Ref(LL <TypedCH> ll) => new Ref
 {
     name = ll.name, CH = ll.pay
 };
Ejemplo n.º 11
0
 public static T findPay <T> (this LL <T> node_in, string search_name) => node_in.findNode(search_name).pay;     // todo remove
Ejemplo n.º 12
0
 public static LL <T> chain <T> (this LL <T> orig, string name, T pay) => new LL <T>(name, pay, orig);
Ejemplo n.º 13
0
 static Ref LL2Ref(LL <preCH> ll) => new Ref
 {
     name = ll.name, pre_ch = ll.pay
 };
Ejemplo n.º 14
0
 public LL(string name, T pay, LL <T> prev)
 {
     this.prev = prev; this.pay = pay; this.name = name;
 }
Ejemplo n.º 15
0
        public readonly LL <TypedCH> LL_head = null;     // empty scope


        CH_closedScope(LL <TypedCH> ll_in)
        {
            LL_head = ll_in;
        }