accessor for Class Variable

  • Thread starter Leonardo Francalanci
  • Start date
L

Leonardo Francalanci

I know it's a stupid question, but I can't find the answer...

Isn't there another way to have an accessor for a class variable than a
"def"??? Something like "attr_reader"?

class Outing < ActiveRecord::Base
@@planingList = [ "YES", "NO", "YES/NO"]

def Outing.wind_directionList
return @@wind_directions
end
end


If the answer is somewhere in the docs, please point me to it.


Thank you
 
R

Robert Klemme

Leonardo Francalanci said:
I know it's a stupid question, but I can't find the answer...

Isn't there another way to have an accessor for a class variable than a
"def"??? Something like "attr_reader"?

Not AFAIK.
class Outing < ActiveRecord::Base
@@planingList = [ "YES", "NO", "YES/NO"]

def Outing.wind_directionList
return @@wind_directions
end
end

In your case you could as well do

class Outing < ActiveRecord::Base
@planingList = [ "YES", "NO", "YES/NO"]

class<<self; attr_reader :planingList end
end
=> ["YES", "NO", "YES/NO"]

Class variables are really only useful if you want to access them from
instances and from the class in a similar way (via "@@var_name").
Otherwise they have more drawbacks than pros so I avoid to use them
whenever I can. (Can't really remember a case where I actually needed
them.)

Kind regards

robert
 
G

gabriele renzi

Leonardo Francalanci ha scritto:
I know it's a stupid question, but I can't find the answer...

Isn't there another way to have an accessor for a class variable than a
"def"??? Something like "attr_reader"?

class Outing < ActiveRecord::Base
@@planingList = [ "YES", "NO", "YES/NO"]

def Outing.wind_directionList
return @@wind_directions
end
end


If the answer is somewhere in the docs, please point me to it.

AFAIK there is not, I think you're supposed to access a class variable
directly from instances and class methods, and to generally use a
constant when possible, wich is visible from outside.
In general the use case for class attributes accessible from the outside
is not that much (in my own experience).

Anyway you should be able to write them easily with something like
(untested):

class Class
def class_attr sym
module_eval "def self.#{sym}() @@#{sym} end"
module_eval "def self.#{sym}=(x) @@#{sym}=x end"
end
end

class C
class_attr :foo
end
 
L

Leonardo Francalanci

class<<self; attr_reader :planingList end


Aaargh... what is that? What does it mean?
Sorry, I'm coming from Java...
 
L

Leonardo Francalanci

AFAIK there is not, I think you're supposed to access a class variable
directly from instances and class methods, and to generally use a
constant when possible, wich is visible from outside.
In general the use case for class attributes accessible from the outside
is not that much (in my own experience).

Ok, got it, I changed them into constants.

Anyway you should be able to write them easily with something like
(untested):

class Class
def class_attr sym
module_eval "def self.#{sym}() @@#{sym} end"
module_eval "def self.#{sym}=(x) @@#{sym}=x end"
end
end

class C
class_attr :foo
end

Wow, looks like I have to learn a lot of stuff...
 
G

gabriele renzi

Leonardo Francalanci ha scritto:
Wow, looks like I have to learn a lot of stuff...

not that much, really, there are a few concepts in ruby with a lot of
usages :)
Anyway, assuming you're italian, I thought I'd point out that there is a
(low traffic) mailing list for italian people that you can subscribe from
http://ada2.unipv.it/ruby

ciao
 
R

Robert Klemme

Leonardo Francalanci said:
Aaargh... what is that? What does it mean?
Sorry, I'm coming from Java...

Then you'll never know... *evil grin*

Ok, class << x ... end is the singleton class of that instance. You can
use that to define methods for a certain instance only (in this case it's
the class). Some examples:

17:20:35 [robert.klemme]: irb
irb(main):001:0> obj = Object.new
=> #<Object:0x101949b8>
irb(main):002:0> def obj.foo() "foo" end
=> nil
irb(main):003:0> obj.foo
=> "foo"
irb(main):004:0> class <<obj
irb(main):005:1> def bar() "<<" + foo() + ">>" end
irb(main):006:1> end
=> nil
irb(main):007:0> obj.bar
=> "<<foo>>"

As a class is an object much like every other object, you can also define
singleton methods for them:

irb(main):008:0> def String.foo() "foo" end
=> nil
irb(main):009:0> String.foo
=> "foo"
irb(main):010:0> class <<String
irb(main):011:1> def bar() "<<" + foo() + ">>" end
irb(main):012:1> end
=> nil
irb(main):013:0> String.bar
=> "<<foo>>"
irb(main):014:0>

Does that help?

Kind regards

robert
 
L

Lyndon Samson

Class variables are really only useful if you want to access them from
instances and from the class in a similar way (via "@@var_name").
Otherwise they have more drawbacks than pros so I avoid to use them
whenever I can. (Can't really remember a case where I actually needed
them.)
What about situations like the following ( taken from an attempt at an
old rubyquiz )

class Op
@@lookup = {}
def Op.register(newOp, newOpClass)
@@lookup[newOp] = newOpClass
end
end

class AddOp < Op
...
end
class SubOp < Op
...
end
class MulOp < Op
...
end
class DivOp < Op
...
end

Op.register("+", AddOp)
Op.register("-", SubOp)
Op.register("*", MulOp)
Op.register("/", DivOp)

They are not really OO 'clean' but better than globals surely?
 
L

Leonardo Francalanci

Sorry, I'm coming from Java...
Then you'll never know... *evil grin*

I knew I shouldn't have said that ;)

Ok, class << x ... end is the singleton class of that instance. You can
use that to define methods for a certain instance only (in this case it's
the class).
As a class is an object much like every other object, you can also define
singleton methods for them

Ok, thanks!
 
N

Nicholas Seckar

I know it's a stupid question, but I can't find the answer...

Isn't there another way to have an accessor for a class variable than a
"def"??? Something like "attr_reader"?

Actually, Rails includes a mechanism to allow class attributes. I
believe the usage is

class Whatever
@@varname = "Default Value"
cattr_accessor :varname
end

I'm not sure if it is documented anywhere though. You can see some
examples here:
http://dev.rubyonrails.com/file/trunk/actionpack/lib/action_controller/base.rb
 
R

Robert Klemme

Lyndon Samson said:
Class variables are really only useful if you want to access them from
instances and from the class in a similar way (via "@@var_name").
Otherwise they have more drawbacks than pros so I avoid to use them
whenever I can. (Can't really remember a case where I actually needed
them.)
What about situations like the following ( taken from an attempt at an
old rubyquiz )

class Op
@@lookup = {}
def Op.register(newOp, newOpClass)
@@lookup[newOp] = newOpClass
end
end

class AddOp < Op
..
end
class SubOp < Op
..
end
class MulOp < Op
..
end
class DivOp < Op
..
end

Op.register("+", AddOp)
Op.register("-", SubOp)
Op.register("*", MulOp)
Op.register("/", DivOp)

They are not really OO 'clean' but better than globals surely?


Yes, but you still don't need a class var - a standard instance var of the
class is sufficient, as you can see:

class Op
@lookup = {}
def self.register(newOp, newOpClass)
@lookup[newOp] = newOpClass
end
end

.... and even saves two chars typing that I could use to replace "Op" by
"self" in the method definition :)))

Kind regards

robert
 
L

Lyndon Samson

Yes, but you still don't need a class var - a standard instance var of the
class is sufficient, as you can see:

class Op
@lookup = {}
def self.register(newOp, newOpClass)
@lookup[newOp] = newOpClass
end
end

.... and even saves two chars typing that I could use to replace "Op" by
"self" in the method definition :)))

Ahh, lightbulbs are going off all over the place here :)

Java has nothing analogous to Class instance variables so i've be
using class variables like statics. But classes are Objects, so why
not treat them likewise. You can even have real singletons in Ruby,
unlike Java where a singleton is unqiue to a ClassLoader.

To paraphrase Alice, cooler and cooler...
 
R

Robert Klemme

Lyndon Samson said:
Yes, but you still don't need a class var - a standard instance var of
the
class is sufficient, as you can see:

class Op
@lookup = {}
def self.register(newOp, newOpClass)
@lookup[newOp] = newOpClass
end
end

.... and even saves two chars typing that I could use to replace "Op" by
"self" in the method definition :)))

Ahh, lightbulbs are going off all over the place here :)

/me puts on his sunglasses.
Java has nothing analogous to Class instance variables so i've be
using class variables like statics. But classes are Objects, so why
not treat them likewise. You can even have real singletons in Ruby,
unlike Java where a singleton is unqiue to a ClassLoader.

.... which isn't necessarily bad: think of a ClassLoader as an application
context (a good example is an app server like Tomcat). You wouldn't want
one apps singletons mess with another apps singletons - at least not
automatically.
To paraphrase Alice, cooler and cooler...

:)

Glad I could help.

CU

robert
 

Ask a Question

Want to reply to this thread or ask your own question?

You'll need to choose a username for the site, which only take a couple of moments. After that, you can post your question and our members will help you out.

Ask a Question

Members online

Forum statistics

Threads
473,744
Messages
2,569,484
Members
44,904
Latest member
HealthyVisionsCBDPrice

Latest Threads

Top