Parents (Total: 23)

The searched file hash is included in 23 parent files which include package known and seen by metalookup. A sample is included below:

Key	Value
MD5	5C254850C9D342771AC5CC8625B387EC
PackageArch	x86_64
PackageDescription	Class::XSAccessor implements fast read, write and read/write accessors in XS. Additionally, it can provide predicates such as 'has_foo()' for testing whether the attribute 'foo' exists in the object (which is different from "is defined within the object"). It only works with objects that are implemented as ordinary hashes. the Class::XSAccessor::Array manpage implements the same interface for objects that use arrays for their internal representation. Since version 0.10, the module can also generate simple constructors (implemented in XS). Simply supply the 'constructor => 'constructor_name'' option or the 'constructors => ['new', 'create', 'spawn']' option. These constructors do the equivalent of the following Perl code: sub new { my $class = shift; return bless { @_ }, ref($class)||$class; } That means they can be called on objects and classes but will not clone objects entirely. Parameters to 'new()' are added to the object. The XS accessor methods are between 3 and 4 times faster than typical pure-Perl accessors in some simple benchmarking. The lower factor applies to the potentially slightly obscure 'sub set_foo_pp {$_[0]->{foo} = $_[1]}', so if you usually write clear code, a factor of 3.5 speed-up is a good estimate. If in doubt, do your own benchmarking! The method names may be fully qualified. The example in the synopsis could have been written as 'MyClass::get_foo' instead of 'get_foo'. This way, methods can be installed in classes other than the current class. See also: the 'class' option below. By default, the setters return the new value that was set, and the accessors (mutators) do the same. This behaviour can be changed with the 'chained' option - see below. The predicates return a boolean. Since version 1.01, 'Class::XSAccessor' can generate extremely simple methods which just return true or false (and always do so). If that seems like a really superfluous thing to you, then consider a large class hierarchy with interfaces such as the PPI manpage. These methods are provided by the 'true' and 'false' options - see the synopsis. 'defined_predicates' check whether a given object attribute is defined. 'predicates' is an alias for 'defined_predicates' for compatibility with older versions of 'Class::XSAccessor'. 'exists_predicates' checks whether the given attribute exists in the object using 'exists'.
PackageName	perl-Class-XSAccessor
PackageRelease	23.1
PackageVersion	1.19
SHA-1	07940618DD26A8A413240CB4F19D5993D12FE5FD
SHA-256	1BC2D28A871CD742B2F3557F568F307EB2E9AFDDD989AC2611EBA651488E1116

Key	Value
MD5	62E89AF903253B76809532512CACC12C
PackageArch	x86_64
PackageDescription	Class::XSAccessor implements fast read, write and read/write accessors in XS. Additionally, it can provide predicates such as 'has_foo()' for testing whether the attribute 'foo' exists in the object (which is different from "is defined within the object"). It only works with objects that are implemented as ordinary hashes. the Class::XSAccessor::Array manpage implements the same interface for objects that use arrays for their internal representation. Since version 0.10, the module can also generate simple constructors (implemented in XS). Simply supply the 'constructor => 'constructor_name'' option or the 'constructors => ['new', 'create', 'spawn']' option. These constructors do the equivalent of the following Perl code: sub new { my $class = shift; return bless { @_ }, ref($class)||$class; } That means they can be called on objects and classes but will not clone objects entirely. Parameters to 'new()' are added to the object. The XS accessor methods are between 3 and 4 times faster than typical pure-Perl accessors in some simple benchmarking. The lower factor applies to the potentially slightly obscure 'sub set_foo_pp {$_[0]->{foo} = $_[1]}', so if you usually write clear code, a factor of 3.5 speed-up is a good estimate. If in doubt, do your own benchmarking! The method names may be fully qualified. The example in the synopsis could have been written as 'MyClass::get_foo' instead of 'get_foo'. This way, methods can be installed in classes other than the current class. See also: the 'class' option below. By default, the setters return the new value that was set, and the accessors (mutators) do the same. This behaviour can be changed with the 'chained' option - see below. The predicates return a boolean. Since version 1.01, 'Class::XSAccessor' can generate extremely simple methods which just return true or false (and always do so). If that seems like a really superfluous thing to you, then consider a large class hierarchy with interfaces such as the PPI manpage. These methods are provided by the 'true' and 'false' options - see the synopsis. 'defined_predicates' check whether a given object attribute is defined. 'predicates' is an alias for 'defined_predicates' for compatibility with older versions of 'Class::XSAccessor'. 'exists_predicates' checks whether the given attribute exists in the object using 'exists'.
PackageMaintainer	https://bugs.opensuse.org
PackageName	perl-Class-XSAccessor
PackageRelease	lp150.1.3
PackageVersion	1.19
SHA-1	0CE9C79A5531F011B48F5A5ECD462CC8D9CD352C
SHA-256	BE89A306B94AF8C0C20C34B2658BC43647771C0B16536268AD10237CA7F3A0FD

Key	Value
MD5	A5157D4392CCCF9602460DE312D1D21E
PackageArch	x86_64
PackageDescription	Class::XSAccessor implements fast read, write and read/write accessors in XS. Additionally, it can provide predicates such as 'has_foo()' for testing whether the attribute 'foo' exists in the object (which is different from "is defined within the object"). It only works with objects that are implemented as ordinary hashes. the Class::XSAccessor::Array manpage implements the same interface for objects that use arrays for their internal representation. Since version 0.10, the module can also generate simple constructors (implemented in XS). Simply supply the 'constructor => 'constructor_name'' option or the 'constructors => ['new', 'create', 'spawn']' option. These constructors do the equivalent of the following Perl code: sub new { my $class = shift; return bless { @_ }, ref($class)||$class; } That means they can be called on objects and classes but will not clone objects entirely. Parameters to 'new()' are added to the object. The XS accessor methods are between 3 and 4 times faster than typical pure-Perl accessors in some simple benchmarking. The lower factor applies to the potentially slightly obscure 'sub set_foo_pp {$_[0]->{foo} = $_[1]}', so if you usually write clear code, a factor of 3.5 speed-up is a good estimate. If in doubt, do your own benchmarking! The method names may be fully qualified. The example in the synopsis could have been written as 'MyClass::get_foo' instead of 'get_foo'. This way, methods can be installed in classes other than the current class. See also: the 'class' option below. By default, the setters return the new value that was set, and the accessors (mutators) do the same. This behaviour can be changed with the 'chained' option - see below. The predicates return a boolean. Since version 1.01, 'Class::XSAccessor' can generate extremely simple methods which just return true or false (and always do so). If that seems like a really superfluous thing to you, then consider a large class hierarchy with interfaces such as the PPI manpage. These methods are provided by the 'true' and 'false' options - see the synopsis. 'defined_predicates' check whether a given object attribute is defined. 'predicates' is an alias for 'defined_predicates' for compatibility with older versions of 'Class::XSAccessor'. 'exists_predicates' checks whether the given attribute exists in the object using 'exists'.
PackageName	perl-Class-XSAccessor
PackageRelease	lp153.22.10
PackageVersion	1.19
SHA-1	0E500B3B224F30F4CFA599C33844F83467AC98BF
SHA-256	79029AE58E45893820B77CF3D6AD2436C90FE783AF94B2DA7C04B6EB8DBA38AA

Key	Value
MD5	CE4EA62A7F5B6ABD52C84474F5607438
PackageArch	x86_64
PackageDescription	Class::XSAccessor implements fast read, write and read/write accessors in XS. Additionally, it can provide predicates such as 'has_foo()' for testing whether the attribute 'foo' exists in the object (which is different from "is defined within the object"). It only works with objects that are implemented as ordinary hashes. the Class::XSAccessor::Array manpage implements the same interface for objects that use arrays for their internal representation. Since version 0.10, the module can also generate simple constructors (implemented in XS). Simply supply the 'constructor => 'constructor_name'' option or the 'constructors => ['new', 'create', 'spawn']' option. These constructors do the equivalent of the following Perl code: sub new { my $class = shift; return bless { @_ }, ref($class)||$class; } That means they can be called on objects and classes but will not clone objects entirely. Parameters to 'new()' are added to the object. The XS accessor methods are between 3 and 4 times faster than typical pure-Perl accessors in some simple benchmarking. The lower factor applies to the potentially slightly obscure 'sub set_foo_pp {$_[0]->{foo} = $_[1]}', so if you usually write clear code, a factor of 3.5 speed-up is a good estimate. If in doubt, do your own benchmarking! The method names may be fully qualified. The example in the synopsis could have been written as 'MyClass::get_foo' instead of 'get_foo'. This way, methods can be installed in classes other than the current class. See also: the 'class' option below. By default, the setters return the new value that was set, and the accessors (mutators) do the same. This behaviour can be changed with the 'chained' option - see below. The predicates return a boolean. Since version 1.01, 'Class::XSAccessor' can generate extremely simple methods which just return true or false (and always do so). If that seems like a really superfluous thing to you, then consider a large class hierarchy with interfaces such as the PPI manpage. These methods are provided by the 'true' and 'false' options - see the synopsis. 'defined_predicates' check whether a given object attribute is defined. 'predicates' is an alias for 'defined_predicates' for compatibility with older versions of 'Class::XSAccessor'. 'exists_predicates' checks whether the given attribute exists in the object using 'exists'.
PackageName	perl-Class-XSAccessor
PackageRelease	lp151.22.1
PackageVersion	1.19
SHA-1	19E085E63C29904148E3FA51EE9177CDEA8D7926
SHA-256	E6583892F7907BB3CB4F482901EBE7BBD82CC9EEFF44C92CB86A18A6C53C8084

Key	Value
MD5	87AF4C706BC8F2A8B181940A4A4B2492
PackageArch	s390x
PackageDescription	Class::XSAccessor implements fast read, write and read/write accessors in XS. Additionally, it can provide predicates such as 'has_foo()' for testing whether the attribute 'foo' exists in the object (which is different from "is defined within the object"). It only works with objects that are implemented as ordinary hashes. the Class::XSAccessor::Array manpage implements the same interface for objects that use arrays for their internal representation. Since version 0.10, the module can also generate simple constructors (implemented in XS). Simply supply the 'constructor => 'constructor_name'' option or the 'constructors => ['new', 'create', 'spawn']' option. These constructors do the equivalent of the following Perl code: sub new { my $class = shift; return bless { @_ }, ref($class)||$class; } That means they can be called on objects and classes but will not clone objects entirely. Parameters to 'new()' are added to the object. The XS accessor methods are between 3 and 4 times faster than typical pure-Perl accessors in some simple benchmarking. The lower factor applies to the potentially slightly obscure 'sub set_foo_pp {$_[0]->{foo} = $_[1]}', so if you usually write clear code, a factor of 3.5 speed-up is a good estimate. If in doubt, do your own benchmarking! The method names may be fully qualified. The example in the synopsis could have been written as 'MyClass::get_foo' instead of 'get_foo'. This way, methods can be installed in classes other than the current class. See also: the 'class' option below. By default, the setters return the new value that was set, and the accessors (mutators) do the same. This behaviour can be changed with the 'chained' option - see below. The predicates return a boolean. Since version 1.01, 'Class::XSAccessor' can generate extremely simple methods which just return true or false (and always do so). If that seems like a really superfluous thing to you, then consider a large class hierarchy with interfaces such as the PPI manpage. These methods are provided by the 'true' and 'false' options - see the synopsis. 'defined_predicates' check whether a given object attribute is defined. 'predicates' is an alias for 'defined_predicates' for compatibility with older versions of 'Class::XSAccessor'. 'exists_predicates' checks whether the given attribute exists in the object using 'exists'.
PackageMaintainer	https://bugs.opensuse.org
PackageName	perl-Class-XSAccessor
PackageRelease	bp154.1.65
PackageVersion	1.19
SHA-1	27251A6B305FA87B2220EE10BED80CFBE7A1CF9B
SHA-256	E1B633DF2B326AD4FCC998539621AFAB634270B15FE2E68ABBE674A4CAA65EA6

Key	Value
MD5	F781D665ABD4351B6D1D61C8418C2141
PackageArch	x86_64
PackageDescription	Class::XSAccessor implements fast read, write and read/write accessors in XS. Additionally, it can provide predicates such as 'has_foo()' for testing whether the attribute 'foo' exists in the object (which is different from "is defined within the object"). It only works with objects that are implemented as ordinary hashes. the Class::XSAccessor::Array manpage implements the same interface for objects that use arrays for their internal representation. Since version 0.10, the module can also generate simple constructors (implemented in XS). Simply supply the 'constructor => 'constructor_name'' option or the 'constructors => ['new', 'create', 'spawn']' option. These constructors do the equivalent of the following Perl code: sub new { my $class = shift; return bless { @_ }, ref($class)||$class; } That means they can be called on objects and classes but will not clone objects entirely. Parameters to 'new()' are added to the object. The XS accessor methods are between 3 and 4 times faster than typical pure-Perl accessors in some simple benchmarking. The lower factor applies to the potentially slightly obscure 'sub set_foo_pp {$_[0]->{foo} = $_[1]}', so if you usually write clear code, a factor of 3.5 speed-up is a good estimate. If in doubt, do your own benchmarking! The method names may be fully qualified. The example in the synopsis could have been written as 'MyClass::get_foo' instead of 'get_foo'. This way, methods can be installed in classes other than the current class. See also: the 'class' option below. By default, the setters return the new value that was set, and the accessors (mutators) do the same. This behaviour can be changed with the 'chained' option - see below. The predicates return a boolean. Since version 1.01, 'Class::XSAccessor' can generate extremely simple methods which just return true or false (and always do so). If that seems like a really superfluous thing to you, then consider a large class hierarchy with interfaces such as the PPI manpage. These methods are provided by the 'true' and 'false' options - see the synopsis. 'defined_predicates' check whether a given object attribute is defined. 'predicates' is an alias for 'defined_predicates' for compatibility with older versions of 'Class::XSAccessor'. 'exists_predicates' checks whether the given attribute exists in the object using 'exists'.
PackageName	perl-Class-XSAccessor
PackageRelease	lp150.22.2
PackageVersion	1.19
SHA-1	55462B4E5A5C902821F6B022E8382A2A054C6A28
SHA-256	FA55E26C31CB5D8A50B3FE7E59C5A479B79799C0DAB981179FB61DC7D699EC3F

Key	Value
MD5	AE753312CCB25788ED4DD0D511B4EDD7
PackageArch	s390x
PackageDescription	Class::XSAccessor implements fast read, write and read/write accessors in XS. Additionally, it can provide predicates such as 'has_foo()' for testing whether the attribute 'foo' exists in the object (which is different from "is defined within the object"). It only works with objects that are implemented as ordinary hashes. the Class::XSAccessor::Array manpage implements the same interface for objects that use arrays for their internal representation. Since version 0.10, the module can also generate simple constructors (implemented in XS). Simply supply the 'constructor => 'constructor_name'' option or the 'constructors => ['new', 'create', 'spawn']' option. These constructors do the equivalent of the following Perl code: sub new { my $class = shift; return bless { @_ }, ref($class)||$class; } That means they can be called on objects and classes but will not clone objects entirely. Parameters to 'new()' are added to the object. The XS accessor methods are between 3 and 4 times faster than typical pure-Perl accessors in some simple benchmarking. The lower factor applies to the potentially slightly obscure 'sub set_foo_pp {$_[0]->{foo} = $_[1]}', so if you usually write clear code, a factor of 3.5 speed-up is a good estimate. If in doubt, do your own benchmarking! The method names may be fully qualified. The example in the synopsis could have been written as 'MyClass::get_foo' instead of 'get_foo'. This way, methods can be installed in classes other than the current class. See also: the 'class' option below. By default, the setters return the new value that was set, and the accessors (mutators) do the same. This behaviour can be changed with the 'chained' option - see below. The predicates return a boolean. Since version 1.01, 'Class::XSAccessor' can generate extremely simple methods which just return true or false (and always do so). If that seems like a really superfluous thing to you, then consider a large class hierarchy with interfaces such as the PPI manpage. These methods are provided by the 'true' and 'false' options - see the synopsis. 'defined_predicates' check whether a given object attribute is defined. 'predicates' is an alias for 'defined_predicates' for compatibility with older versions of 'Class::XSAccessor'. 'exists_predicates' checks whether the given attribute exists in the object using 'exists'.
PackageMaintainer	https://bugs.opensuse.org
PackageName	perl-Class-XSAccessor
PackageRelease	bp156.3.4
PackageVersion	1.19
SHA-1	5867EEE4C3F71C18F1880CD4EFB4977F5D5ECCA7
SHA-256	FDAB1311F4159AD45C1B0B490F6CF6992B578371D0C2DC60DE1C69C62B99EBFD

Key	Value
MD5	084C9B27CAD4C02074F4DA90D323AA1C
PackageArch	s390x
PackageDescription	Class::XSAccessor implements fast read, write and read/write accessors in XS. Additionally, it can provide predicates such as 'has_foo()' for testing whether the attribute 'foo' exists in the object (which is different from "is defined within the object"). It only works with objects that are implemented as ordinary hashes. the Class::XSAccessor::Array manpage implements the same interface for objects that use arrays for their internal representation. Since version 0.10, the module can also generate simple constructors (implemented in XS). Simply supply the 'constructor => 'constructor_name'' option or the 'constructors => ['new', 'create', 'spawn']' option. These constructors do the equivalent of the following Perl code: sub new { my $class = shift; return bless { @_ }, ref($class)||$class; } That means they can be called on objects and classes but will not clone objects entirely. Parameters to 'new()' are added to the object. The XS accessor methods are between 3 and 4 times faster than typical pure-Perl accessors in some simple benchmarking. The lower factor applies to the potentially slightly obscure 'sub set_foo_pp {$_[0]->{foo} = $_[1]}', so if you usually write clear code, a factor of 3.5 speed-up is a good estimate. If in doubt, do your own benchmarking! The method names may be fully qualified. The example in the synopsis could have been written as 'MyClass::get_foo' instead of 'get_foo'. This way, methods can be installed in classes other than the current class. See also: the 'class' option below. By default, the setters return the new value that was set, and the accessors (mutators) do the same. This behaviour can be changed with the 'chained' option - see below. The predicates return a boolean. Since version 1.01, 'Class::XSAccessor' can generate extremely simple methods which just return true or false (and always do so). If that seems like a really superfluous thing to you, then consider a large class hierarchy with interfaces such as the PPI manpage. These methods are provided by the 'true' and 'false' options - see the synopsis. 'defined_predicates' check whether a given object attribute is defined. 'predicates' is an alias for 'defined_predicates' for compatibility with older versions of 'Class::XSAccessor'. 'exists_predicates' checks whether the given attribute exists in the object using 'exists'.
PackageMaintainer	https://bugs.opensuse.org
PackageName	perl-Class-XSAccessor
PackageRelease	bp153.1.17
PackageVersion	1.19
SHA-1	5AF9810C8728D9C72EA8C37AEFD08FB731220C3D
SHA-256	2970993C1FB95E6D6F8A2AD994C32D8705A20B324AD4EF96548172B933123A72

Key	Value
MD5	DBA2624ABED04F819AC5CE918930CB55
PackageArch	x86_64
PackageDescription	Class::XSAccessor implements fast read, write and read/write accessors in XS. Additionally, it can provide predicates such as 'has_foo()' for testing whether the attribute 'foo' exists in the object (which is different from "is defined within the object"). It only works with objects that are implemented as ordinary hashes. the Class::XSAccessor::Array manpage implements the same interface for objects that use arrays for their internal representation. Since version 0.10, the module can also generate simple constructors (implemented in XS). Simply supply the 'constructor => 'constructor_name'' option or the 'constructors => ['new', 'create', 'spawn']' option. These constructors do the equivalent of the following Perl code: sub new { my $class = shift; return bless { @_ }, ref($class)||$class; } That means they can be called on objects and classes but will not clone objects entirely. Parameters to 'new()' are added to the object. The XS accessor methods are between 3 and 4 times faster than typical pure-Perl accessors in some simple benchmarking. The lower factor applies to the potentially slightly obscure 'sub set_foo_pp {$_[0]->{foo} = $_[1]}', so if you usually write clear code, a factor of 3.5 speed-up is a good estimate. If in doubt, do your own benchmarking! The method names may be fully qualified. The example in the synopsis could have been written as 'MyClass::get_foo' instead of 'get_foo'. This way, methods can be installed in classes other than the current class. See also: the 'class' option below. By default, the setters return the new value that was set, and the accessors (mutators) do the same. This behaviour can be changed with the 'chained' option - see below. The predicates return a boolean. Since version 1.01, 'Class::XSAccessor' can generate extremely simple methods which just return true or false (and always do so). If that seems like a really superfluous thing to you, then consider a large class hierarchy with interfaces such as the PPI manpage. These methods are provided by the 'true' and 'false' options - see the synopsis. 'defined_predicates' check whether a given object attribute is defined. 'predicates' is an alias for 'defined_predicates' for compatibility with older versions of 'Class::XSAccessor'. 'exists_predicates' checks whether the given attribute exists in the object using 'exists'.
PackageMaintainer	https://bugs.opensuse.org
PackageName	perl-Class-XSAccessor
PackageRelease	lp152.3.2
PackageVersion	1.19
SHA-1	64EA75BBF5D99DE56D9FEEC7F48FE965834E8C17
SHA-256	2532D6FB304A96299B25938E03F92D8558B5D71E7B30C823DE5B5AB12155B3D1

Key	Value
MD5	4056F4984A185A73120FFC6EABA0D85D
PackageArch	x86_64
PackageDescription	Class::XSAccessor implements fast read, write and read/write accessors in XS. Additionally, it can provide predicates such as 'has_foo()' for testing whether the attribute 'foo' exists in the object (which is different from "is defined within the object"). It only works with objects that are implemented as ordinary hashes. the Class::XSAccessor::Array manpage implements the same interface for objects that use arrays for their internal representation. Since version 0.10, the module can also generate simple constructors (implemented in XS). Simply supply the 'constructor => 'constructor_name'' option or the 'constructors => ['new', 'create', 'spawn']' option. These constructors do the equivalent of the following Perl code: sub new { my $class = shift; return bless { @_ }, ref($class)||$class; } That means they can be called on objects and classes but will not clone objects entirely. Parameters to 'new()' are added to the object. The XS accessor methods are between 3 and 4 times faster than typical pure-Perl accessors in some simple benchmarking. The lower factor applies to the potentially slightly obscure 'sub set_foo_pp {$_[0]->{foo} = $_[1]}', so if you usually write clear code, a factor of 3.5 speed-up is a good estimate. If in doubt, do your own benchmarking! The method names may be fully qualified. The example in the synopsis could have been written as 'MyClass::get_foo' instead of 'get_foo'. This way, methods can be installed in classes other than the current class. See also: the 'class' option below. By default, the setters return the new value that was set, and the accessors (mutators) do the same. This behaviour can be changed with the 'chained' option - see below. The predicates return a boolean. Since version 1.01, 'Class::XSAccessor' can generate extremely simple methods which just return true or false (and always do so). If that seems like a really superfluous thing to you, then consider a large class hierarchy with interfaces such as the PPI manpage. These methods are provided by the 'true' and 'false' options - see the synopsis. 'defined_predicates' check whether a given object attribute is defined. 'predicates' is an alias for 'defined_predicates' for compatibility with older versions of 'Class::XSAccessor'. 'exists_predicates' checks whether the given attribute exists in the object using 'exists'.
PackageMaintainer	https://bugs.opensuse.org
PackageName	perl-Class-XSAccessor
PackageRelease	bp156.3.4
PackageVersion	1.19
SHA-1	7D1CAEC9B353B5EBE6C2A3FB6FF79BB4708C3297
SHA-256	2CF2516BBD1C69DBECE4B485B413F869D017B7742865FB302A96BFE6E8302318