How to create "def method(item)= (value)" ?

[Iñaki Baz Castillo]

SGksIGlzIGl0IG5vdCBwb3NzaWJsZSB0byBjcmVhdGUgYSBtZXRob2QgdG8gdXNlIGluIHRoaXMg
d2F5PwoKICAgbXlfb2JqZWN0LnBhcmFtKCJ0YWciKSA9ICJuZXdfdmFsdWUiCgpIb3cgdG8gZGVm
aW5lIHRoYXQgbWV0aG9kPyBJJ3ZlIHRyeWVkIHNvbWV0aGluZyBhczoKCiAgZGVmIHBhcmFtKG5h
bWUpPSAodmFsdWUpCiAgICBAcGFyYW1zW25hbWVdID0gdmFsdWUKICBlbmQKCmJ1dCBvYnZpb3Vz
bHkgSSBnZXQgZXJyb3I6CgogIFN5bnRheEVycm9yOiBjb21waWxlIGVycm9yCiAgc3ludGF4IGVy
cm9yLCB1bmV4cGVjdGVkICc9JwoKSXMgdGhlcmUgc29tZSB3YXk/IFRoYW5rcyBhIGxvdC4KCi0t
IApJw7Fha2kgQmF6IENhc3RpbGxvCjxpYmNAYWxpYXgubmV0Pgo=

 

[Phillip Gawlowski]

-----BEGIN PGP SIGNED MESSAGE-----
Hash: SHA1

Iñaki Baz Castillo wrote:
| Hi, is it not possible to create a method to use in this way?
|
| my_object.param("tag") = "new_value"
|
| How to define that method? I've tryed something as:
|
| def param(name)= (value)
| @params[name] = value
| end
|
| but obviously I get error:
|
| SyntaxError: compile error
| syntax error, unexpected '='
|
| Is there some way? Thanks a lot.
|

Untested, and probably highly inelegant:

def param key, value
~ @params["#{key.to_sym}"] = value
end

Should produce:

| object.params my_key, 'my value'
=> @params[:my_key] => 'my value'

While not the interface you desire, it is the output you want.

(May be useful as a Rails helper, but otherwise?)

Or, you could use an optionhash to create your method:
,http://www.lukeredpath.co.uk/2006/7/27/using-ruby-hashes-as-keyword-arguments-with-easy-defaults>

Something like:

def param(options = {})
~ @params[options.key] = options[options.key]
end

should look like

| object.param 'key' => 'value'
=> @params['key'] => 'value'


You could sexy that up with Hash#merge:

def param(options = {})
~ @params = @params.merge options
end

(probably more efficient than the first variant, too.)


Hope that helps.

- --
Phillip Gawlowski
Twitter: twitter.com/cynicalryan
Blog: http://justarubyist.blogspot.com

~ - You know you've been hacking too long when...
...you want to wash your hair and think: awk -F"/neck" '{ print $1 }' |
shower
-----BEGIN PGP SIGNATURE-----
Version: GnuPG v1.4.8 (MingW32)
Comment: Using GnuPG with Mozilla - http://enigmail.mozdev.org

iEYEARECAAYFAkgYawQACgkQbtAgaoJTgL82BACgjop7Cr5BFncX8igZrmTsDZJd
rT8Anjx643D6wDFImBbkLWG/rEXA00mv
=r9VE
-----END PGP SIGNATURE-----

 

[Iñaki Baz Castillo]

MjAwOC80LzMwLCBQaGlsbGlwIEdhd2xvd3NraSA8Y21kamFja3J5YW5AZ29vZ2xlbWFpbC5jb20+
OgoKPiAgVW50ZXN0ZWQsIGFuZCBwcm9iYWJseSBoaWdobHkgaW5lbGVnYW50Ogo+Cj4gIGRlZiBw
YXJhbSBrZXksIHZhbHVlCj4gIH4gIEBwYXJhbXNbIiN7a2V5LnRvX3N5bX0iXSA9IHZhbHVlCj4g
IGVuZAo+Cj4gIFNob3VsZCBwcm9kdWNlOgo+Cj4gIHwgb2JqZWN0LnBhcmFtcyBteV9rZXksICdt
eSB2YWx1ZScKPiAgPT4gQHBhcmFtc1s6bXlfa2V5XSA9PiAnbXkgdmFsdWUnCj4KPiAgV2hpbGUg
bm90IHRoZSBpbnRlcmZhY2UgeW91IGRlc2lyZSwgaXQgaXMgdGhlIG91dHB1dCB5b3Ugd2FudC4K
ClllcywgdGhhdCBleGFjdGx5IHdoYXQgSSBkbywgYnV0IEkgZG9uJ3QgbGlrZSBpdCwgc2luY2Ug
aXQncyBub3QKaW50dWl0aXZlLiBJbiBmYWN0IEkgY2FsbCB0aGUgbWV0aG9kICJzZXRfcGFyYW0o
bmFtZSwgdmFsdWUpIi4gQnV0IGl0Cm1ha2VzIHRoZSBjb2RlIGxvb2sgbGlrZSBKYXZhLi4gYnJy
cnJyLi4uLiBYRAoKCj4gIHwgb2JqZWN0LnBhcmFtICdrZXknID0+ICd2YWx1ZScKPiAgPT4gQHBh
cmFtc1sna2V5J10gPT4gJ3ZhbHVlJwo+Cj4KPiAgWW91IGNvdWxkIHNleHkgdGhhdCB1cCB3aXRo
IEhhc2gjbWVyZ2U6Cj4KPiAgZGVmIHBhcmFtKG9wdGlvbnMgPSB7fSkKPiAgfiAgQHBhcmFtcyA9
IEBwYXJhbXMubWVyZ2Ugb3B0aW9ucwo+ICBlbmQKPgo+ICAocHJvYmFibHkgbW9yZSBlZmZpY2ll
bnQgdGhhbiB0aGUgZmlyc3QgdmFyaWFudCwgdG9vLikKCkludGVyZXN0aW5nLCBhbmQgdGhhbmtz
IGZvciB0aGUgdXNlZnVsIGxpbmsuIDopCgoKLS0gCknDsWFraSBCYXogQ2FzdGlsbG8KPGliY0Bh
bGlheC5uZXQ+Cg==

 

[Phillip Gawlowski]

-----BEGIN PGP SIGNED MESSAGE-----
Hash: SHA1

David A. Black wrote:

|> | object.params my_key, 'my value'
|> => @params[:my_key] => 'my value'
|
| "#{key.to_sym}" is always going to produce a string, never a symbol.

*facepalm* Right. String interpolation. Too clever for my own good, is
what I am..

| I'm not sure the OP wants to constrain the keys to be symbols anyway.

Well, given that Rails uses the params hash, with Symbols as keys, I
took a guess.

Also, it is a bit of a habit on my part to use Symbols, instead of
strings or so.

| Also, you're calling params; I think you mean param.

Yes, indeed. Typo on my part (I cought it the other two chances..).


|
| You could also do:
|
| def param[]=(key,value)
| @params[key] = value
| end
|
| object.param[key] = value

Oh, I'm gonna steal that idiom if you don't mind.


- --
Phillip Gawlowski
Twitter: twitter.com/cynicalryan
Blog: http://justarubyist.blogspot.com

~ "My ethicator machine must've had a built-in moral compromise
~ spectral release phantasmatron! I'm a genius!" --- Calvin
-----BEGIN PGP SIGNATURE-----
Version: GnuPG v1.4.8 (MingW32)
Comment: Using GnuPG with Mozilla - http://enigmail.mozdev.org

iEYEARECAAYFAkgYb78ACgkQbtAgaoJTgL9uFwCeKmz6hTAVyts6LCR67Va7hvkF
ucQAnR8ZQiObqzUcJD+WbLGRUmnshy5i
=/Utl
-----END PGP SIGNATURE-----

 

[Iñaki Baz Castillo]

MjAwOC80LzMwLCBEYXZpZCBBLiBCbGFjayA8ZGJsYWNrQHJ1YnlwYWwuY29tPjoKCj4gIFlvdSBj
b3VsZCBhbHNvIGRvOgo+Cj4gICBkZWYgcGFyYW1bXT0oa2V5LHZhbHVlKQo+ICAgICBAcGFyYW1z
W2tleV0gPSB2YWx1ZQo+ICAgZW5kCj4KPiAgIG9iamVjdC5wYXJhbVtrZXldID0gdmFsdWUKClRo
YXQncyBub3QgdmFsaWQsIGEgbWV0aG9kIGNhbm5vdCBjb250YWluIFtdOgoKaXJiPiBkZWYgaG9s
YVtdKCkgZW5kClN5bnRheEVycm9yOiBjb21waWxlIGVycm9yCnN5bnRheCBlcnJvciwgdW5leHBl
Y3RlZCAnWycsIGV4cGVjdGluZyAnXG4nIG9yICc7JwpkZWYgaG9sYVtdKCkgZW5kCgoKPiAgT2Yg
Y291cnNlLCB0aGVuIG9uZSBtaWdodCBhcyB3ZWxsIGRvOgo+Cj4gICBhdHRyX3JlYWRlciA6cGFy
YW1zCj4KPiAgb24gdGhlIG9iamVjdCwgYW5kIHRoZW06Cj4KPiAgIG9iamVjdC5wYXJhbXNba2V5
XSA9IHZhbHVlCgpZZXMsIGJ1dCB0aGF0IGlzIG5vdCB2YWxpZCBmb3IgbWUgc2luY2UgSSBuZWVk
IHRvIGV4ZWMgc29tZSBleHRyYSBjb2RlCnNvIEkgbmVlZCB0byBjcmVhdGUgYW4gYWJzdHJhY3Rp
b24gbGF5ZXIgdG8gYWNjZXNzIEBwYXJhbXMuCgoKVGhhbmtzLgoKCi0tIApJw7Fha2kgQmF6IENh
c3RpbGxvCjxpYmNAYWxpYXgubmV0Pgo=

 

[Phillip Gawlowski]

-----BEGIN PGP SIGNED MESSAGE-----
Hash: SHA1

Iñaki Baz Castillo wrote:

|
| Yes, that exactly what I do, but I don't like it, since it's not
| intuitive. In fact I call the method "set_param(name, value)". But it
| makes the code look like Java.. brrrrr.... XD

Not commenting on the Java part (the naming in Java is usually rather
well done, IMO), but I agree, the solution isn't all too elegant because
of it's lack of intuitive assignment.

Usually, I use something like that, when I am too lazy to create an
optionhash based solution.

*adds that to TODO list for a current project*

|
| Interesting, and thanks for the useful link.

You are welcome.

- --
Phillip Gawlowski
Twitter: twitter.com/cynicalryan
Blog: http://justarubyist.blogspot.com

Do you know why the fairy sits at the top of the Xmas tree ?

~ One year, Santa had one tree left over after giving everybody one, and
when one of his fairy helpers asked what she should do with it, he told her.

~ That`s why.
-----BEGIN PGP SIGNATURE-----
Version: GnuPG v1.4.8 (MingW32)
Comment: Using GnuPG with Mozilla - http://enigmail.mozdev.org

iEYEARECAAYFAkgYcJsACgkQbtAgaoJTgL+HaACeMiqRAOW+QZob0dVSghldpG/Z
b7QAoJpDBoN1X8WgA9pxjUwYu1RbJHf3
=DZOH
-----END PGP SIGNATURE-----

 

[Chris Hulan]

Why not just access param?

class Foo
def initialize
@param = {}
end
attr_accessor aram
end

x = Foo.new
x.param['key'] = 'bar'


If you do need to override it, the Hash assignment method is []=
So I think you can write:
def []=(key,value)
....


Cheers

 

[Iñaki Baz Castillo]

MjAwOC80LzMwLCBQaGlsbGlwIEdhd2xvd3NraSA8Y21kamFja3J5YW5AZ29vZ2xlbWFpbC5jb20+
Ogo+ICB8IFlvdSBjb3VsZCBhbHNvIGRvOgo+ICB8Cj4gIHwgICBkZWYgcGFyYW1bXT0oa2V5LHZh
bHVlKQo+ICB8ICAgICBAcGFyYW1zW2tleV0gPSB2YWx1ZQo+ICB8ICAgZW5kCj4gIHwKPiAgfCAg
IG9iamVjdC5wYXJhbVtrZXldID0gdmFsdWUKPgo+ICBPaCwgSSdtIGdvbm5hIHN0ZWFsIHRoYXQg
aWRpb20gaWYgeW91IGRvbid0IG1pbmQuIDspCgpJJ20gc29ycnksIGJ1dCBhcyBJJ3ZlIHJlcGxp
ZWQgaW4gdGhpcyB0aHJlYWQgdGhhdCBtZXRob2QgbmFtaW5nCih1c2luZyBbXSkgaXMgaW52YWxp
ZCBpbiBSdWJ5ICA6KAoKCi0tIApJw7Fha2kgQmF6IENhc3RpbGxvCjxpYmNAYWxpYXgubmV0Pgo=

 

[Phillip Gawlowski]

-----BEGIN PGP SIGNED MESSAGE-----
Hash: SHA1

Iñaki Baz Castillo wrote:
| 2008/4/30, Phillip Gawlowski <[email protected]>:
|> | You could also do:
|> |
|> | def param[]=(key,value)
|> | @params[key] = value
|> | end
|> |
|> | object.param[key] = value
|>
|> Oh, I'm gonna steal that idiom if you don't mind.
|
| I'm sorry, but as I've replied in this thread that method naming
| (using []) is invalid in Ruby

Sort of. As a singleton method, you get the syntax error. But not if you
define [] as a method:

irb(main):001:0> def []=(key,value)
irb(main):002:1> end
=> nil

- --
Phillip Gawlowski
Twitter: twitter.com/cynicalryan
Blog: http://justarubyist.blogspot.com

~ "It's great to have a friend who appreciates an earnest discussion of
ideas." -Calvin
-----BEGIN PGP SIGNATURE-----
Version: GnuPG v1.4.8 (MingW32)
Comment: Using GnuPG with Mozilla - http://enigmail.mozdev.org

iEYEARECAAYFAkgYdR8ACgkQbtAgaoJTgL8u3wCeJBjJgyJ61Uvxx29wpoiYzx+N
YjUAnjvAmG8+itc/5/337GSz37rH64zm
=f5M/
-----END PGP SIGNATURE-----

 

[Iñaki Baz Castillo]

MjAwOC80LzMwLCBQaGlsbGlwIEdhd2xvd3NraSA8Y21kamFja3J5YW5AZ29vZ2xlbWFpbC5jb20+
Ogo+ICBTb3J0IG9mLiBBcyBhIHNpbmdsZXRvbiBtZXRob2QsIHlvdSBnZXQgdGhlIHN5bnRheCBl
cnJvci4gQnV0IG5vdCBpZiB5b3UKPiAgZGVmaW5lIFtdIGFzIGEgbWV0aG9kOgo+Cj4gIGlyYiht
YWluKTowMDE6MD4gZGVmIFtdPShrZXksdmFsdWUpCj4gIGlyYihtYWluKTowMDI6MT4gZW5kCj4g
ID0+IG5pbAoKWWVzLCBidXQgSSBuZWVkICJkZWYgc29tZV9uYW1lW10iICAgIDopCgotLSAKScOx
YWtpIEJheiBDYXN0aWxsbwo8aWJjQGFsaWF4Lm5ldD4K

 

[David A. Black]

Hi --

| You could also do:
|
| def param[]=(key,value)
| @params[key] = value
| end
|
| object.param[key] = value

Oh, I'm gonna steal that idiom if you don't mind.

Sorry -- it's wrong. I think I've remembered what I meant to write.
This time, let's go all out and try the code!

object = Object.new
class << object
attr_accessor arams
end
object.params = {}

def object.[]=(key,value)
@params[key] = value
end

object[1] = 2

p object.params # { 1 => 2 }

Too bad -- I kind of liked my garbled rubbish version


David

--
Rails training from David A. Black and Ruby Power and Light:
INTRO TO RAILS June 9-12 Berlin
ADVANCING WITH RAILS June 16-19 Berlin
INTRO TO RAILS June 24-27 London (Skills Matter)
See http://www.rubypal.com for details and updates!

 

[Phillip Gawlowski]

-----BEGIN PGP SIGNED MESSAGE-----
Hash: SHA1

David A. Black wrote:

|>
|> Sort of. As a singleton method, you get the syntax error. But not if you
|> define [] as a method:
|>
|> irb(main):001:0> def []=(key,value)
|> irb(main):002:1> end
|> => nil
|
| It's not the singletonness that stops it; you can do this:
|
| def object.[]=(k,v) # etc.
|
| What made my example wrong was that I had concocted an illegal method
| name.

Though, it should (might?) be possible to implemetn something like
Hash's or Array's

hash[key]
array[index]

index methods for plain old object instances, too.

I haven't seen such an implementation, though, and my C and Java fu are
too weak to make sense of JRuby or CRuby.

Maybe Rubinius is a starting point, since it supposedly implement core
classes in Ruby.

- --
Phillip Gawlowski
Twitter: twitter.com/cynicalryan
Blog: http://justarubyist.blogspot.com

ABORT: Drivel filter is compromised!
-----BEGIN PGP SIGNATURE-----
Version: GnuPG v1.4.8 (MingW32)
Comment: Using GnuPG with Mozilla - http://enigmail.mozdev.org

iEYEARECAAYFAkgYe9kACgkQbtAgaoJTgL+gSwCghRVTOxl1IlMKSoNZzq98d1F1
+88AnRieQmvx+CEX4pidn6qfqJe/5TT7
=3zqI
-----END PGP SIGNATURE-----

 

[Iñaki Baz Castillo]

MjAwOC80LzMwLCBEYXZpZCBBLiBCbGFjayA8ZGJsYWNrQHJ1YnlwYWwuY29tPjoKCj4gIG9iamVj
dCA9IE9iamVjdC5uZXcKPiAgY2xhc3MgPDwgb2JqZWN0Cj4gICBhdHRyX2FjY2Vzc29yIDpwYXJh
bXMKPiAgZW5kCj4gIG9iamVjdC5wYXJhbXMgPSB7fQo+Cj4gIGRlZiBvYmplY3QuW109KGtleSx2
YWx1ZSkKPiAgIEBwYXJhbXNba2V5XSA9IHZhbHVlCj4gIGVuZAo+Cj4gIG9iamVjdFsxXSA9IDIK
Pgo+ICBwIG9iamVjdC5wYXJhbXMgICAjIHsgMSA9PiAyIH0KCgpPaCwgdGhhdCBzZWVtcyByZWFs
bHkgaW50ZXJlc3RpbmcsIGJ1dCB1bmZvcnR1bmF0ZWxseSBJIGNhbid0CnVuZXJzdGFuZCBhdCBh
bGwgd2hhdCB5dW8gZG8gdGhlcmUuClNwZWNpYWxseSBJIGRvbid0IHVuZGVyc3RhbmQgdGhlIG1l
YW5pbmcgb2YgZmlyc3QgdHdvIGxpbmVzOgoKICBvYmplY3QgPSBPYmplY3QubmV3CiAgY2xhc3Mg
PDwgb2JqZWN0CgpXaGF0IGRvZXMgdGhhdCAiY2xhc3MiIG1lYW4/PwoKVGhhbmtzIGEgbG90LgoK
LS0gCknDsWFraSBCYXogQ2FzdGlsbG8KPGliY0BhbGlheC5uZXQ+Cg==

 

[ts]

#what I want but it's not possible:

There is always the stupid way

vgs% cat b.rb
#!/usr/bin/ruby
class A
class Int__
def initialize(obj, name)
@self = obj
@name = name
end

def []=(x, y)
s = @self
n = @name
s.instance_eval {
instance_variable_get(n)[x] = y
@modified = true
}
end
end

def param
@param ||= {}
Int__.new(self, '@param')
end
end

a = A.new
a.param[:x] = 24
p a
vgs%

vgs% ./b.rb
#<A:0xb7c9e3cc @param={:x=>24}, @modified=true>
vgs%


Guy Decoux

 

[David A. Black]

Hi --

-----BEGIN PGP SIGNED MESSAGE-----
Hash: SHA1

David A. Black wrote:

|>
|> Sort of. As a singleton method, you get the syntax error. But not if you
|> define [] as a method:
|>
|> irb(main):001:0> def []=(key,value)
|> irb(main):002:1> end
|> => nil
|
| It's not the singletonness that stops it; you can do this:
|
| def object.[]=(k,v) # etc.
|
| What made my example wrong was that I had concocted an illegal method
| name.

Though, it should (might?) be possible to implemetn something like
Hash's or Array's

hash[key]
array[index]

index methods for plain old object instances, too.

Sure:

def object.[](index)
# derive value you want here
end

And then:

object[something]

You always get the [] syntactic sugar for free when you define [].


David

--
Rails training from David A. Black and Ruby Power and Light:
INTRO TO RAILS June 9-12 Berlin
ADVANCING WITH RAILS June 16-19 Berlin
INTRO TO RAILS June 24-27 London (Skills Matter)
See http://www.rubypal.com for details and updates!

 

[Ken Bloom]

Hi, is it not possible to create a method to use in this way?

my_object.param("tag") = "new_value"

How to define that method? I've tryed something as:

def param(name)= (value)
@params[name] = value
end

but obviously I get error:

SyntaxError: compile error
syntax error, unexpected '='

Is there some way? Thanks a lot.

def initialize
@params={}
end

def param
@params
end

my_object.param["tag"]="new value"

If you need some sort of validation, you can have param return some other
class that defines [] and []= and does the necessary validation, and you
can even set up an easy method for defining the param attribute to do all
of that if need be.

 

[Chris Hulan]

2008/4/30, Chris Hulan <[email protected]>:

Why not just access param?

class Foo
def initialize
@param = {}
end
attr_accessor aram
end

x = Foo.new
x.param['key'] = 'bar'

If you do need to override it, the Hash assignment method is []=
So I think you can write:
def []=(key,value)
...

Because I need to give value to an attribute of a class containing the
Hash @params, so the only way (AFAIK) is by creating an abstraction
layer and handling the Hash @params via current class methods. This is
my case:

class Uri

# Atributes:
@modified => true/false
@params => Hash

attr_accessor :modified

#what I want but it's not possible:
def param(name)= (value)
@params[name] = value
@modified = true
end

end

I can't do it by extending Hash class since inside Hash class I can't
modify @modified attribute.
Also note there are more ways than "=" to modify a Hash value:
@params[name].strip! , .chomp! , .downcase! ......
and I don't want to redefine all of them so I just want to allow "="
and when it's called @modifed must be true.

Hope I've explained why attr_accessor is not useful for me in this case.

Thanks a lot.

Create your own Hash subclass?

def MyBag

def initialize(parent)
@parent = parent
@theBag = {}
end

def []=(k,v)
@theBag[k] = v
@parent.modified = true
end

def [](k)
@theBag[k]
end
end

class Uri
def initialize
@params = MyBag.new(self) #need to do this in initialize,
otherwise self is not the instance
@modified = false
end
attr_accessor :modified, arams

end

Not tested, and there is most likely a more elegant way to delegate to
Hash, but you get what you pay for 9^)

 

[Phillip Gawlowski]

-----BEGIN PGP SIGNED MESSAGE-----
Hash: SHA1

Iñaki Baz Castillo wrote:

| Oh, that seems really interesting, but unfortunatelly I can't
| unerstand at all what yuo do there.
| Specially I don't understand the meaning of first two lines:
|
| object = Object.new
| class << object
|
| What does that "class" mean??

it's the class keyword to define classes.

class << object
~ # stuff here
end

extends the object instance on the spot, instead of, for example,
re-creating 'object' / inheriting from another class (like Array), and
extending your child.

- --
Phillip Gawlowski
Twitter: twitter.com/cynicalryan
Blog: http://justarubyist.blogspot.com

~ "When life gives you a lemon, make lemonade." -Susie "I say, when
life gives you a lemon, wing it right back and add some lemons of your
own!" -Calvin
-----BEGIN PGP SIGNATURE-----
Version: GnuPG v1.4.8 (MingW32)
Comment: Using GnuPG with Mozilla - http://enigmail.mozdev.org

iEYEARECAAYFAkgYfsUACgkQbtAgaoJTgL/bigCglTM/NCalvkJ+XWzjGPg2v2Cn
1o8AnRUAjt9JDN3NjnTf5C1AeMc6l906
=L5yX
-----END PGP SIGNATURE-----

 

[Iñaki Baz Castillo]

MjAwOC80LzMwLCBEYXZpZCBBLiBCbGFjayA8ZGJsYWNrQHJ1YnlwYWwuY29tPjoKCj4gPiBXaGF0
IGRvZXMgdGhhdCAiY2xhc3MiIG1lYW4/Pwo+Cj4gIGh0dHA6Ly93d3cud29iYmxpbmkubmV0L3Np
bmdsZXRvbnMuaHRtbAoKT2gsIGhhdmUgeW91IHdyaXR0ZW4gYWxsIHRoaXMgZG9jdW1lbnRhdGlv
biBqdXN0IG5vdyB0byBleHBsYWluIG1lPwp0aGFua3MgYSBsb3QhIQpYRERERAoKCi0tIApJw7Fh
a2kgQmF6IENhc3RpbGxvCjxpYmNAYWxpYXgubmV0Pgo=

 

[Iñaki Baz Castillo]

MjAwOC80LzMwLCBDaHJpcyBIdWxhbiA8Y2hyaXMuaHVsYW5AZ21haWwuY29tPjoKPiAgQ3JlYXRl
IHlvdXIgb3duIEhhc2ggc3ViY2xhc3M/Cj4KPiAgZGVmIE15QmFnCj4KPiAgIGRlZiBpbml0aWFs
aXplKHBhcmVudCkKPiAgICAgQHBhcmVudCA9IHBhcmVudAo+ICAgICBAdGhlQmFnID0ge30KPiAg
IGVuZAo+Cj4gICBkZWYgW109KGssdikKPiAgICAgQHRoZUJhZ1trXSA9IHYKPiAgICAgQHBhcmVu
dC5tb2RpZmllZCA9IHRydWUKPiAgIGVuZAoKU2ltcGx5IGdyZWF0ISEhCgpJJ3ZlIGxlYXJudCBh
IExPVCBvZiBSdWJ5IG1hZ2ljIGluIHRoaXMgdGhyZWFkLCB0aGFua3MgdG8gYWxsIGZvciBhbGwK
dGhlIHNvbHV0aW9ucyA6KQoKCi0tIApJw7Fha2kgQmF6IENhc3RpbGxvCjxpYmNAYWxpYXgubmV0
Pgo=