Πέμπτη, 16 Νοεμβρίου 2017

Αναθεώρηση 9 Έκδοση 9.0

Διορθώθηκε η κλήση τμήματος της υπερκλάσης από τμήμα ενός αντικείμενου που συνδέεται με αυτήν την υπερκλάση, όταν αυτό το αντικείμενο βρίσκεται σε τμήμα άλλου αντικειμένου! (Μπέρδεμα μόνο να το γράψεις...που να το λύσεις κιόλας). Το λάθος έβγαινε στην σημειωμένη με κόκκινο εντολή! Μόνο αν το module bb ήταν σε ομάδα! Αν δεν ήταν δεν είχε θέμα!
Στην PrintData καλούμε μέσω της For SuperClass {} μια συνάρτηση που καλεί και αυτή την SuperClass {} μιας ομάδας της Epsilon για να γυρίσει το counter (το οποίο δώσαμε ως μοναδικό, uniqe, με την B2)

Ο διερμηνευτής δεν αφήνει να κάνουμε πάνω από μια φορά το άνοιγμα της υπερκλάσης, όμως εδώ έχουμε δυο υπερκλάσεις. Δείτε τι συμβαίνει. η Alfa έχει τη Beta ως περιεχόμενη ομάδα. Δίνουμε σε κάθε ομάδα μια υπερκλάση, που στην ουσία είναι μια αναφορά σε μια ομάδα που δεν έχει πια "θέση" πουθενά, παρά υπάρχει όσο υπάρχουν αναφορές σε αυτήν. Αν η υπερκλάση είχε κάτι άλλο εκτός από μοναδικό θα τα είχε αποκτήσει και η ομάδα που θέτουμε την υπερκλάση. Εδώ έχουμε μόνο έναν μετρητή, και επειδή βάζουμε την Α στην Αλφα, και την Β1 στην Beta σημαίνει ότι έχουμε δυο μετρητές κοινούς, για όποιες ομάδες έχουν την ίδια υπερκλάση. 'Οχι τον τύπο της, αλλά την αναφορά της, άρα και τον τύπο της. Έχει σημασία αυτό γιατί  θα μπορούσαμε να δίναμε την Β2, η οποία είναι ακριβώς ίδια ως τύπος αλλά είναι άλλη, που σημαίνει ότι άλλες ομάδες μπορεί να μην σχετίζονται με αυτήν.Έτσι η υπερκλάση μας ενδιαφέρει ως κάτι το μοναδικό που αναφέρται σε αυτό μια ομάδα, είτε αυτή είναι μόνη της, είτε ανήκει σε άλλες ομάδες.
Οι ομάδες στην Μ2000 έχουν την λειτουργία συγχώνευσης, Αν δώσουμε στην Marshal1 την υπερκλάση Α, δεν θα έχει μέλη, αλλά θα έχει μια αναφορά στην Α (σε αυτό που το Α αναφέρεται, και το Α λειτουργεί σαν δείκτης, αλλά δείχνει ότι είναι ομάδα). Με την δήλωση Group Marshal1 {} φτιάχνουμε εκ των υστέρων μέλη, όπως το τμήμα INC για να αυξάνουμε τον μετρητή της υπερκλάσης, του Α. Μπορούμε με την κλάση AnyMarshal να παράγουμε ομάδες, on the fly, και να τις συγχωνεύουμε, όπως κάνουμε με τα Marshal2 και Marshal3

Ομοίως φτιάχνουμε και την Alfa και την δική του Beta. Θέλουμε όταν καλούμε την Alfa.Beta.SuperClass.Counter() να μας δίνει το counter της B1 υπερκλάσης. Επίσης θέλουμε όταν καλούμε την Alfa.PrintData να μας δίνει και τα δυο counter! Για το δεύτερο πρέπει να καλέσουμε την .Beta.SuperClass.Counter(), και επειδή έχουμε ανοίξει με το For SuperClass {} την υπερκλάση, θα εμφανισεί λογικά με το .counter αυτό της υπερκλάσης και με το This.Beta.SuperClass.Counter() ζητάμε να καλέσουμε το Beta.SuperClass.Counter() και αυτό να καλέσει την δική του υπερκλάσει και να πάρει την δική του counter και να την επιστρέψει στη Print της PrintData.
Στο παράδειγμα κάνουμε και αλλαγή της υπερκλάσεις, αλλά όλο αυτό δούλευε και πριν την αναθεώρηση 9. Το πρόβλημα ήταν στην συγχώνευση του Alfa στο Epsilon σε σχέση με το αν αυτή γίνεται σε ένα απλή Module ή σε ένα Module σε μια ομάδα. Αν γίνονταν σε απλό τμήμα (module), τότε δεν υπήρχε πρόβλημα. Εν τέλει βρέθηκε πως θα λυθεί , χωρίς να έχει γίνει γνωστό επακριβώς τι του δημιουργούσε πρόβλημα. Δηλαδή δόθηκε μια λύση, από το πλάι! Δόθηκε μια πληροφορία που γνώριζε το αντικείμενο εκτέλεσης, και έτσι  όταν πράγματι ο "νορμάλ" τρόπος αστοχεί δίνει την λύση αυτή η πληροφορία, που εδώ είναι το αντικείμενο Epsilon. Πώς γίνεται και η Epsilon.Printdata δεν γνωρίζει το αντικείμενο Epsilon; To περίμενε με ένα όνομα το οποίο δεν είχε! Δείτε ότι το τμήμα
Epsilon.Printdata δεν έχει δείκτη που να δείχνει πιο είναι το αντικείμενο! Αυτό που έχει είναι  ένα πρόθεμα που βάζει αντί για το This και την εύρεση την κάνει ο διερμημευτής!
Αν και λύση δόθηκε, δεν έχω ακόμα βγάλει το συμπέρασμα τι είναι αυτό που δημιουργεί το λάθος. Ξέρω σε ποια γραμμή γίνεται, και απλά έβαλα ένα ElseIF όταν προκύπτει το λάθος, συν μια λύση, γιατί απλά είδα ότι το προηγούμενο IF δεν είχε το όνομα για να βρει τη σωστή μεταβλητή!
Δηλαδή στο προγραμματισμό μπορούμε να δώσουμε λύσεις ακόμα και αν δεν έχουμε κατανοήσει το πρόβλημα!






Class zz {
      module bb {
            Superclass A {
                  unique:
                  counter
            }
            Superclass B1 {
                  unique:
                  counter
            }
            Superclass B2 {
                  unique:
                  counter
            }
            \\ We can make a group Alfa with a member, another group Beta
            \\ Group Beta can't see parent group, but can see own member groups
            \\ Group Alfa can see everything in nested groups, in any level,
            \\ but can't see inside modules/functions/operator/value/set
            Group Alfa {
                  Group Beta { }
            }
            Alfa=A
            Alfa.Beta=B1
            \\ we make 3 groups for marshaling counters
            \\ each group get a superclass
            Marshal1=A
            Marshal2=B1
            Marshal3=B2
            \\ Now we want to add functionallity7
            \\ Inc module to add 1 to counter
            \\ a Value function to return counter
            \\ Without Value a group return a copy
            \\ If a group has a value then we can get copy using Group(nameofgroup)
            \\ just delete Group Marshal1 and remove Rem when we make Marshal1 using a class function
            Group Marshal1 {
                  Module Inc {
                        For SuperClass {.counter++}
                  }
                  Value {
                        For SuperClass {=.counter}
                  }
            }
            Class AnyMarshal {
                  Module Inc {
                        For SuperClass {.counter++}
                  }
                  Value {
                        For SuperClass {=.counter}
                  }
            }
            \\ here we merge groups
            Rem : Marshal1=AnyMarshal()
            Marshal2=AnyMarshal()
            Marshal3=AnyMarshal()
           
            \\ So now we see counters (three zero)
            Print Marshal1, Marshal2, Marshal3 \\ 0, 0, 0
            \\ Now we prepare Alfa and Alfa.Beta groups
            Group Alfa {
                  Group Beta {
                        Function SuperClass.Counter {
                              For SuperClass {
                                    =.counter
                              }           
                        }      
                  }
                  Module PrintData {
                        For SuperClass {
                              Print .counter, This.Beta.SuperClass.Counter()
                        }
                  }
            }
            \\ some marshaling to counters
            Marshal1.inc
            Marshal2.inc
            Marshal2.inc
            Marshal3.inc
            \\ lets print results
            Print Marshal1, Marshal2, Marshal3 \\ 1   2   1
            \\ Calling Alfa.PrintData
            Alfa.PrintData  \\ 1   2
            \\ Merging a group in a group make a change to superclass pointer inside group
            Alfa.Beta=B2 \\ change supeclass
            Alfa.PrintData  \\ 1   1
            For i=1 to 10 : Marshal3.inc : Next i
            Alfa.PrintData  \\ 1   11
            Alfa.Beta=B1 \\ change supeclass
            Alfa.PrintData  \\ 1   2
            Epsilon=Alfa
            Print Valid(@alfa as epsilon), Valid(@alfa.beta as epsilon.beta) \\ -1   -1
            Epsilon.PrintData \\ 1 2
            Alfa.Beta=B2 \\ change supeclass
            Alfa.PrintData  \\ 1   11
            Epsilon.PrintData \\ 1 2
            \\ validation being for top group superclass and all members if are same
            \\ but not for inner superclasses. This maybe change in later revisions of language.
            Print Valid(@alfa as epsilon), Valid(@alfa.beta as epsilon.beta) \\ -1  0
          
      }
}
Dim A(10)
A(3)=zz()
A(3).bb