Ring Documentation, Release 1.5.

In the previous example we have the local variable name.

The value of this variable will be set to “mahmoud” instead of the object attribute.
Solution (1) : Just use Self
func main
name = "nice"
o1 = new person {self.name="mahmoud" address="Egypt" phone = 000 }
see o1

class person
name
address
phone

Solution (2) : Change the Local variable name

func main
cName = "nice"
o1 = new person {name="mahmoud" address="Egypt" phone = 000 }
see o1

class person
name
address
phone

Solution (3) : Change Braces and use the Dot operator

func main
name = "nice"
o1 = new person
o1.name ="mahmoud"
o1.address ="Egypt"
o1.phone = 000
see o1

class person
name
address
phone

60.9 Using Braces to access objects inside Class Methods

Remember that we have Three scopes (Local Scope, Object Scope and Global Scope) and when we are inside a class
method, we expect that we have access to the object attributes and methods and this is true until we use braces to
access another object attributes and methods because in this case our object scope will be switched to another object.
new point { test() }

class point
x=10 y=20
func test
see x + nl + y + nl # works fine
myobj = new otherclass {
see name + nl
see x + nl + y + nl # error !

60.9. Using Braces to access objects inside Class Methods 695

 Ring Documentation, Release 1.5.4

class otherclass
name = "test"

Output:
10
20
test

Line 8 Error (R24) : Using uninitialized variable : x

In method test() in file methodbraceerror.ring
called from line 5 in file methodbraceerror.ring

Now what we will do to solve the previous problem?

Solution (1) : Write the code that access the class attributes outside braces.
new point { test() }

class point
x=10 y=20
func test
see x + nl + y + nl # works fine
myobj = new otherclass {
see name + nl
}
see x + nl + y + nl # Outside braces - works fine

class otherclass
name = "test"

Output:
10
20
test
10
20

Solution (2) : Don’t Use Braces

new point { test() }

class point
x=10 y=20
func test
see x + nl + y + nl
myobj = new otherclass
see myobj.name
see x + nl + y + nl

class otherclass
name = "test"

Solution (3) : Copy the self object

We may use this solution if we want to use braces and get access to the class attributes (Just Reading).

60.9. Using Braces to access objects inside Class Methods 696

 Ring Documentation, Release 1.5.4

new point { test() }

class point
x=10 y=20
func test
oSelf = self
see x + nl + y + nl
myobj = new otherclass {
see name + nl
see oself.x + nl + oself.y + nl
}

class otherclass
name = "test"

Output:
10
20
test
10
20

Now look at this line

oself = self

The problem with the previous line is that we will have a new copy from the object Because in Ring the assignment
operator copy lists and objects by value (not by reference).
When we access the new object attributes (reading) we don’t have problems
But if we modified the object attributes (Then we will modify the copy!).

Note: We can use braces again with the copy

new point { test() }

class point
x=10 y=20
func test
oSelf = self
see x + nl + y + nl
myobj = new otherclass {
see name + nl
oSelf {
see x + nl + y + nl
}
}

class otherclass
name = "test"

In a GUI application, we may create a class contains the window objects as attributes to be able to access the controls
from different methods. Remember the previous information when you try to access objects using braces inside
methods because in this case you can’t access the object attributes directly and if you copied the self object you will
work on a copy and the new controls that you create will be related to the copy and you can’t access them.

60.9. Using Braces to access objects inside Class Methods 697

 Ring Documentation, Release 1.5.4

60.10 Accessing the class attributes from braces inside class meth-
ods

We access the class attributes directly from the class methods, also we have the choice to use the Self reference before
the attribute/method name. Using Braces {} inside class method change the active object scope and prevent us from
getting direct access to the class attributes. Also using Self will not help because the Self reference will be changed to
the object that we access using Braces.
In this case if you want to read an attribute you have to copy the Self object before using Braces and if you want to
modify an attribute you have to the copy from local variable to the object attribute after using Braces.
This case happens when you want to read/modify attribute insead braces.
Class MyApp

oCon # Attribute

# some code here

Func OpenDatabase
# some code here
new QSqlDatabase() {
oCon = addDatabase("QSQLITE") {
setDatabaseName("weighthistory.db")
open()
}
}
self.oCon = oCon
# some code here

In the previous example we want to create the connection object and save it inside the oCon attribute.
The object is an output from the addDatabase() method that we use after accessing the QSQLDatabase() object.
Inside braces we can’t use the Self reference to use the object created from the MyApp class, Because the Self reference
here will be to the object that we access using Braces.
We solved the problem in the previous example by creating a local variable called oCon then after Braces we copied
that variable to the oCon attribute.
The next code is another solution.
Class MyApp

oCon # Attribute

# some code here

Func OpenDatabase
# some code here
oCon = new QSqlDatabase()
oCon = oCon.addDatabase("QSQLITE") {
setDatabaseName("weighthistory.db")
Open()
}
# some code here

The next code is a better solution.

60.10. Accessing the class attributes from braces inside class methods 698
 Ring Documentation, Release 1.5.4

Class MyApp

oCon # Attribute

# some code here

Func OpenDatabase
# some code here
new QSqlDatabase() {
this.oCon = addDatabase("QSQLITE") {
setDatabaseName("weighthistory.db")
Open()
}
}
# some code here

Note: We used this.attribute to access the class attribute (oCon) while we are inside Braces.

60.11 Creating a Class for each Window in GUI applications

A good way for creating classes for windows is to define the window directly after the class name
In this area you can use nested braces without problems to define the window and the controls, and they will be
attributes that you can access from methods.
Example:
Load "guilib.ring"

new qApp
{
$ObjectName = "oFirstWindow"
oFirstWindow = new FirstWindow

$ObjectName = "oSecondWindow"
oSecondWindow = new SecondWindow

exec()
}

Class FirstWindow

win = new qWidget() {

setgeometry(0,50,300,200)
setWindowTitle("First Window")
label1 = new qLabel(win)
{
setgeometry(10,10,300,30)
setText("0")
}
btn1 = new qPushButton(win)
{
move(100,100)
setText("Increment")
setClickEvent($ObjectName+".increment()")
}

60.11. Creating a Class for each Window in GUI applications 699

 Ring Documentation, Release 1.5.4

show()
}

Func Increment
label1 {
setText( "" + ( 0 + text() + 1 ) )
}

Class SecondWindow

win = new qWidget() {

setgeometry(400,50,300,200)
setWindowTitle("Second Window")
label1 = new qLabel(win)
{
setgeometry(10,10,300,30)
setText("0")
}
btn1 = new qPushButton(win)
{
move(100,100)
setText("Decrement")
setClickEvent($ObjectName+".decrement()")
}
show()
}

Func Decrement
label1 {
setText( "" + ( 0 + text() - 1 ) )
}

60.12 Conflict between self inside braces and self in the class region

In the class region (after the class name and before any methods) we define the attributes.
In this region we have access to the global scope and the local scope will point to the object scope.
Three Scopes
• Global Scope —> Gloabl Scope
• Object Scope —> Object Scope
• Local Scope —> Object Scope
Look at this example
New Account {
see aFriends
}

Class Account
name = "Mahmoud"
aFriends = []
aFriends + new Friend {
name = "Gal"

60.12. Conflict between self inside braces and self in the class region 700
 Ring Documentation, Release 1.5.4

}
aFriends + new Friend {
name = "Bert"
}

Class Friend
name

Output:
name: NULL
name: NULL

The problem in the previous example is that the Class account contains an attribute called “name” and the Friend class
contains an attribue called “name” also.
If you tried using self.name inside braces you will get the same result!
New Account {
see aFriends
}

Class Account
name = "Mahmoud"
aFriends = []
aFriends + new Friend {
self.name = "Gal"
}
aFriends + new Friend {
self.name = "Bert"
}

Class Friend
name

So why using self.name inside braces doesn’t solve this conflict?

Because after the class region we have
• global scope —> global scope
• object scope —> object scope (Account Class)
• local scope —> local scope (Account Class)
When we use braces we change the object scope, so we have
• global scope —> global scope
• object scope —> object scope (Friend Class)
• local scope —> local scope (Account Class)
Ring search in the local scope first, so using self.name will use the Account class.
There are many solution
Solution (1) : Access the object through the list
New Account {
see aFriends
}

Class Account

60.12. Conflict between self inside braces and self in the class region 701
 Ring Documentation, Release 1.5.4

name = "Mahmoud"
aFriends = []
aFriends + new Friend
aFriends[len(aFriends)] {
aFriends[len(aFriends)].name = "Gal"
}
aFriends + new Friend
aFriends[len(aFriends)] {
aFriends[len(aFriends)].name = "Bert"
}

Class Friend
name

Solution (2) : Create Method in the friend class to set the name attribute.
New Account {
see aFriends
}

Class Account
name = "Mahmoud"
aFriends = []
aFriends + new Friend {
setname("Gal")
}
aFriends + new Friend {
setname("Bert")
}

Class Friend
name
func setname cName
name = cName

Solution (3) : Create a method in the account class to set the attribute
New Account {
see aFriends
}

Class Account
name = "Mahmoud"
aFriends = []
friend("Gal")
friend("Bert")

func friend cName

aFriends + new Friend {
name = cName
}

Class Friend
name

Solution (4) : Declarative Programming

New Account {
name = "mahmoud"
friend {

60.12. Conflict between self inside braces and self in the class region 702
 Ring Documentation, Release 1.5.4

name = "Gal"
}
friend {
name = "Bert"
}
see aFriends
}

Class Account
name
aFriends = []
friend
func getfriend
aFriends + new Friend
return aFriends[len(aFriends)]

Class Friend
name

Output:
name: Gal
name: Bert

60.13 Using braces to escape from the current object scope

Since braces change the current object scope to another object. we can use it to do some work without modifying the
class attributes and using the same variable names.
new point {x=10 y=20 z=30 start() }
class point x y z
func start
see self # print the x y z values (10,20,30)
new Local {
x = 100
y = 200
z = 300
}
see self # print the x y z values (10,20,30)
see x + nl # will print 100
see y + nl # will print 200
see z + nl # will print 300
Self { # NO Advantage - Search is done in local scope first
see x + nl # will print 100
see y + nl # will print 200
see z + nl # will print 300
}
see self.x + nl # will print 10
see self.y + nl # will print 20
see self.z + nl # will print 30

class Local

Output:
x: 10.000000
y: 20.000000

60.13. Using braces to escape from the current object scope 703
 Ring Documentation, Release 1.5.4

z: 30.000000
x: 10.000000
y: 20.000000
z: 30.000000
100
200
300
100
200
300
10
20
30

60.14 Summary of Scope Rules

At first remember that

1 - Each programming language comes with it’s scope rules based on the language goals
2 - Programming in the small is different than Programming in the Large
3 - Some programming language are designed for developing small programs while others are designed for large
programs
4 - In programming, If we have access to more than one scope - Then problems may come if we don’t manage things
correctly
5 - It’s always more secure to reduce the number of visible scopes
6 - Some programming languages force you to manage the scope in some way, while others not!
In Ring
1 - Special and very simple scope rules that are designed for Flexibility first then Security
2 - Ring is designed to support programming in the small and programming in the large.
3 - The language provide the different programming paradigms that you may select from based on the project size.
Errors comes only if you selected a bad paradigm for the target project or you are using the paradigm in a way that is
not correct or at least not common.
4 - In Ring you have the choice, you can use global variables or avoid them. you can give them a special $ mark or
leave them. you can use object-oriented or stay with procedures. you can use the class region (after the class name
and before any method) just for attributes or use it for code too.
5 - Just read the next scope rules and think about them then use them in your favorite way.
Scope Rules:
1 - At any place in our program code we have only at maximum Three Scopes (Local Scope, Object Scope and Global
Scope).
2 - When Ring find a variable it will search in the local scope first then in the object scope then in the global scope.
3 - At any time inside procedures or methods you can use braces { } to access an object and change the current object
scope.
4 - In the class region (After the class name and before any method) this is a special region where both of the object
scope and the local scope point to the object scope. I.e. No local variables where each variable you define in this
region will become an attribute.

60.14. Summary of Scope Rules 704