1MakeMethods::Composite:U:sGelrobCaoln(t3r)ibuted Perl DoMcaukmeeMnettahtoidosn::Composite::Global(3)
2
6 Class::MakeMethods::Composite::Global - Global data
7
9 package MyClass;
10 use Class::MakeMethods::Composite::Global (
11 scalar => [ 'foo' ],
12 array => [ 'my_list' ],
13 hash => [ 'my_index' ],
14 );
15 ...
16 MyClass->foo( 'Foozle' );
18 print MyClass->foo();
19 print MyClass->new(...)->foo(); # same value for any instance
21 print MySubclass->foo(); # ... and for any subclass
22 MyClass->my_list(0 => 'Foozle', 1 => 'Bang!');
24 print MyClass->my_list(1);
25 MyClass->my_index('broccoli' => 'Blah!', 'foo' => 'Fiddle');
27 print MyClass->my_index('foo');
28
30 The Composite::Global suclass of MakeMethods provides basic accessors
31 for shared data.
32 Class::MakeMethods Calling Interface
34 When you "use" this package, the method declarations you provide as
35 arguments cause subroutines to be generated and installed in your
36 module.
37 You can also omit the arguments to "use" and instead make methods at
39 runtime by passing the declarations to a subsequent call to "make()".
40 You may include any number of declarations in each call to "use" or
42 "make()". If methods with the same name already exist, earlier calls to
43 "use" or "make()" win over later ones, but within each call, later
44 declarations superceed earlier ones.
45 You can install methods in a different package by passing "-TargetClass
47 => package" as your first arguments to "use" or "make".
48 See Class::MakeMethods for more details.
50 Class::MakeMethods::Basic Declaration Syntax
52 The following types of Basic declarations are supported:
53 · generator_type => "method_name"
55 · generator_type => "name_1 name_2..."
57 · generator_type => [ "name_1", "name_2", ...]
59 See the "METHOD GENERATOR TYPES" section below for a list of the
61 supported values of generator_type.
62 For each method name you provide, a subroutine of the indicated type
64 will be generated and installed under that name in your module.
65 Method names should start with a letter, followed by zero or more
67 letters, numbers, or underscores.
68 Class::MakeMethods::Composite Declaration Syntax
70 The Composite syntax also provides several ways to optionally associate
71 a hash of additional parameters with a given method name.
72 · generator_type => [ "name_1" => { param=>value... }, ... ]
74 A hash of parameters to use just for this method name.
76 (Note: to prevent confusion with self-contained definition hashes,
78 described below, parameter hashes following a method name must not
79 contain the key 'name'.)
80 · generator_type => [ [ "name_1", "name_2", ... ] => {
82 param=>value... } ]
83 Each of these method names gets a copy of the same set of
85 parameters.
86 · generator_type => [ { "name"=>"name_1", param=>value... }, ... ]
88 By including the reserved parameter "name", you create a self-
90 contained declaration with that name and any associated hash
91 values.
92 Basic declarations, as described above, are given an empty parameter
94 hash.
95
97 scalar - Global Accessor
98 For each method name passed, uses a closure to generate a subroutine
99 with the following characteristics:
100 · May be called as a class method, or on any instance or subclass,
102 and behaves identically regardless of what it was called on.
103 · If called without any arguments returns the current value.
105 · If called with an argument, stores that as the value, and returns
107 it,
108 · If called with multiple arguments, stores a reference to a new
110 array with those arguments as contents, and returns that array
111 reference.
112 Sample declaration and usage:
114 package MyClass;
116 use Class::MakeMethods::Composite::Global (
117 scalar => 'foo',
118 );
119 ...
120 # Store value
122 MyClass->foo('Foozle');
123 # Retrieve value
125 print MyClass->foo;
126 array - Global Ref Accessor
128 For each method name passed, uses a closure to generate a subroutine
129 with the following characteristics:
130 · May be called as a class method, or on any instance or subclass,
132 and behaves identically regardless of what it was called on.
133 · The global value will be a reference to an array (or undef).
135 · If called without any arguments, returns the current array-ref
137 value (or undef).
138 · If called with a single non-ref argument, uses that argument as an
140 index to retrieve from the referenced array, and returns that value
141 (or undef).
142 · If called with a single array ref argument, uses that list to
144 return a slice of the referenced array.
145 · If called with a list of argument pairs, each with a non-ref index
147 and an associated value, stores the value at the given index in the
148 referenced array. If the global value was previously undefined, a
149 new array is autovivified. The current value in each position will
150 be overwritten, and later arguments with the same index will
151 override earlier ones. Returns the current array-ref value.
152 · If called with a list of argument pairs, each with the first item
154 being a reference to an array of up to two numbers, loops over each
155 pair and uses those numbers to splice the value array.
156 The first controlling number is the position at which the splice
158 will begin. Zero will start before the first item in the list.
159 Negative numbers count backwards from the end of the array.
160 The second number is the number of items to be removed from the
162 list. If it is omitted, or undefined, or zero, no items are
163 removed. If it is a positive integer, that many items will be
164 returned.
165 If both numbers are omitted, or are both undefined, they default to
167 containing the entire value array.
168 If the second argument is undef, no values will be inserted; if it
170 is a non-reference value, that one value will be inserted; if it is
171 an array-ref, its values will be copied.
172 The method returns the items that removed from the array, if any.
174 Sample declaration and usage:
176 package MyClass;
178 use Class::MakeMethods::Composite::Global (
179 array => 'bar',
180 );
181 ...
182 # Clear and set contents of list
184 print MyClass->bar([ 'Spume', 'Frost' ] );
185 # Set values by position
187 MyClass->bar(0 => 'Foozle', 1 => 'Bang!');
188 # Positions may be overwritten, and in any order
190 MyClass->bar(2 => 'And Mash', 1 => 'Blah!');
191 # Retrieve value by position
193 print MyClass->bar(1);
194 # Direct access to referenced array
196 print scalar @{ MyClass->bar() };
197 There are also calling conventions for slice and splice operations:
199 # Retrieve slice of values by position
201 print join(', ', MyClass->bar( undef, [0, 2] ) );
202 # Insert an item at position in the array
204 MyClass->bar([3], 'Potatoes' );
205 # Remove 1 item from position 3 in the array
207 MyClass->bar([3, 1], undef );
208 # Set a new value at position 2, and return the old value
210 print MyClass->bar([2, 1], 'Froth' );
211 hash - Global Ref Accessor
213 For each method name passed, uses a closure to generate a subroutine
214 with the following characteristics:
215 · May be called as a class method, or on any instance or subclass,
217 and behaves identically regardless of what it was called on.
218 · The global value will be a reference to a hash (or undef).
220 · If called without any arguments, returns the contents of the hash
222 in list context, or a hash reference in scalar context (or undef).
223 · If called with one non-ref argument, uses that argument as an index
225 to retrieve from the referenced hash, and returns that value (or
226 undef).
227 · If called with one array-ref argument, uses the contents of that
229 array to retrieve a slice of the referenced hash.
230 · If called with one hash-ref argument, sets the contents of the
232 referenced hash to match that provided.
233 · If called with a list of key-value pairs, stores the value under
235 the given key in the referenced hash. If the global value was
236 previously undefined, a new hash is autovivified. The current value
237 under each key will be overwritten, and later arguments with the
238 same key will override earlier ones. Returns the contents of the
239 hash in list context, or a hash reference in scalar context.
240 Sample declaration and usage:
242 package MyClass;
244 use Class::MakeMethods::Composite::Global (
245 hash => 'baz',
246 );
247 ...
248 # Set values by key
250 MyClass->baz('foo' => 'Foozle', 'bar' => 'Bang!');
251 # Values may be overwritten, and in any order
253 MyClass->baz('broccoli' => 'Blah!', 'foo' => 'Fiddle');
254 # Retrieve value by key
256 print MyClass->baz('foo');
257 # Retrive slice of values by position
259 print join(', ', MyClass->baz( ['foo', 'bar'] ) );
260 # Direct access to referenced hash
262 print keys %{ MyClass->baz() };
263 # Reset the hash contents to empty
265 @{ MyClass->baz() } = ();
266 object - Global Ref Accessor
268 For each method name passed, uses a closure to generate a subroutine
269 with the following characteristics:
270 · May be called as a class method, or on any instance or subclass,
272 and behaves identically regardless of what it was called on.
273 · The global value will be a reference to an object (or undef).
275 · If called without any arguments returns the current value.
277 · If called with an argument, stores that as the value, and returns
279 it,
280 Sample declaration and usage:
282 package MyClass;
284 use Class::MakeMethods::Composite::Global (
285 object => 'foo',
286 );
287 ...
288 # Store value
290 MyClass->foo( Foozle->new() );
291 # Retrieve value
293 print MyClass->foo;
294
296 See Class::MakeMethods for general information about this distribution.
297 See Class::MakeMethods::Composite for more about this family of
299 subclasses.
300perl v5.32.0 2020-07-28 MakeMethods::Composite::Global(3)