Cobra Forums

namespace ESutils

    class Globalz
        enum Coin
            heads, tails
        
        const someConstant as uint32 = 37
            
        var _ticksPerSecond as decimal
        
        pro ticksPerSecond as decimal
            get
                return _ticksPerSecond
            set
                _ticksPerSecond = value

    class SomeMain
        def main
            a = 3 + Globalz.someConstant
            a = a + MyRandom.next(7, 8)
            print [a]

    class MyRandom inherits Random
        cue init is shared
            base.init

        def next(lowValue as int, highValue as int) as int    #fix next from random class,
            assert lowValue <= highValue
            assert highValue + 1 <= int.maxValue
            return base.next(lowValue, highValue + 1)
                
        def coinToss as Globalz.Coin
            if .next(0, 1) == 0
                return Coin.heads
            else
                return Coin.tails

class X

    const answerToLife = 42

enum Coin
    heads, tails

interface IDoSomething
    def doSomething

sig MathMethod(a as int, b as int) as int

class Prog

    def main
        print X.answerToLife

namespace NS

    class X

        const answerToLife = 42

    enum Coin
        heads, tails

    interface IDoSomething
        def doSomething

    sig MathMethod(a as int, b as int) as int

class Application

    var windows as List<of Window> is shared
    
    cue init is shared
        .windows = List<of Window>()
        
    def main
        trace .windows

class Window
    pass

class Window
    pass

class Application

    shared

        var windows as List<of Window>
    
        cue init
            .windows = List<of Window>()
        
    def main
        trace .windows

class Window
    pass

class Application

    shared

        var _windows = List<of Window>()
        
        def addWindow(w as Window)
            lock _windows, _windows.add(w)

        def hasWindow(w as Window) as bool
            lock _windows, return _windows.contains(w)

        def removeWindow(w as Window)
            lock _windows, _windows.remove(w)
        
        get windows as IList<of Window>
            """ Returns a new list of windows at the time of invocation. """
            lock _windows, return _windows.clone

    def main
        trace .windows

class AppWide

    shared

        var _random as Random?
        
        get random as Random
            if _random is nil, _random = Random()
            return _random to !

class Prog

    def main
        trace AppWide.random.next

class AppWide

    shared

        var _random as Random?
        
        get random as Random
            if _random is nil, _random = Random()
            return _random to !

extend Object

    def random as Random
        return AppWide.random

class Prog

    def main
        trace .random.next


class Foo

    def bar
        trace .random.next

var _ticksPerSecond as decimal
pro ticksPerSecond from var

# or implicitly get the backing variable generated
pro ticksPerSecond as decimal from var

import ESUtils
...
a = Globalz.someConstant + 3
a = a + Globalz.MyRandom.next(7, 8)

#probably clearer in client code to give the full namespace and Object spec ( no import)
a = ESUtils.Globalz.someConstant + 3
a = a + ESUtils.Globalz.MyRandom.next(7, 8)

class MyRandom inherits Random
        shared 
              var _instance as Random # = Random() 

              cue init
                   base.init

              def next(lowValue as int, highValue as int) as int   #fix next from random class,
                  assert lowValue <= highValue
                  assert highValue + 1 <= int.maxValue
                  if not _instance    # first call
                      _instance = Random()  #, instantiate the singleton instance with whatever ctor values desired 
                 #every other operation use singleton instance to provide the operation
                  return _instance.next(lowValue, highValue + 1)


# elsewhere use as 

a = a + MyRandom.next(7,8) #if imported
...
b = 3 + Utils.MyRandom.next(10,20) # MyRandom in Utils namespace

Namespace Factory
   class Random 
       '''Factory class for production of Random generators of various capabilities all inheriting from  System.Random()'''
        var _single as Globalz.MyRandom

        '''Singleton-ness functionality provided by factory'''
         def single as System.Random is shared
              if not _single 
                  _single = Globalz.MyRandom() # passing any specific args
                  #_single = NonProduction.MyOtherRandom()  #alternative randomGenerator
              return _single
 
       '''Alternative triggered by a string selector'''
       def generator(pars as List of String) as System.Random is shared
            if pars.contains('myrandom')
                return Globalz.MyRandom()
            if pars.contains('std')
                return System.Random()
            if pars.contains('test')
                return TestRandom()
            if pars.contains('bad')
               return RandomNextAlwaysReturnsOne()

           throw FallThroughException('Parameter not in "myrandom", "std", "test" "bad"')

       '''Alternative triggered by a an underlying selector not part of caller API'''
       def generator() as System.Random is shared
            par = System.Environment('WhatRandom')
            # could also read this from a properties file or other configurable lookup
            if par == 'myrandom'
                return Globalz.MyRandom()
            if par == 'std'
                return System.Random()
            if par == 'test'
                return TestRandom()
            if par == 'bad'
               return RandomNextAlwaysReturnsOne()

           throw FallThroughException('Config error:  getRandomGenerator parameter not in "myrandom", "std", "test" "bad"')


# Use like 

a = a + Factory.Random.single.next(7, 8)
...
# or more likely
randm = Factory.Random.single
...
a = a+ randm.next(7,8)
...
b = 3 + randm.next(8, 16)

trace customer.balanceDue
# you can have more that one item:
trace x, y

enum Pitch
    A = 123
    A_again = 123
    B = 456