NAME
C<LibXML::Class::Attr> - collection of attribute descriptors


head

This module is a container for the following attribute descriptors:


item

See the L<I<LICENSE>|../../../../LICENSE> file in this distribution.


root

para

L<Examples| file:../examples/index.podlite>


L<Download |file:../download/index.podlite>


React

=begin React :component<HeaderCol> :id<menu> 
=para L<Documentation|/doc/introduction>
=para L<Modules| /mods>
=para L<Examples| file:../examples/index.podlite>
=para L<Download |file:../download/index.podlite>
=para L<About|file:../about/index.podlite>
=para 🔍 K<⌘K>/K<ctrl-K>
=end React


HEADER

FOOTER

Attr

NAME
C<LibXML::Class::Attr::Node> - base role of attribute descriptors, implements namespace-awareness


This role consumes L<C<LibXML::Class::Attr::XMLish>|XMLish.md> and L<C<LibXML::Class::Descriptor>|../Descriptor.md>.


Node

C<LibXML::Class> – general purpose XML de-/serialization for Raku


code

=begin code :lang<raku>
use LibXML::Class;

class Record1 is xml-element {
    has Int:D $.id is required;
    has Str $.description;
    has %.meta;
}

my $rec = Record1.new(:id(1000), :description("test me"), :meta{ key1 => π, key2 => "some info" });

say $rec.to-xml.Str(:format);
=end code


output

=begin output :lang<xml>
<?xml version="1.0" encoding="UTF-8"?>
<Record1 id="1000" description="test me">
  <meta>
    <key1>3.141592653589793e+00</key1>
    <key2>some info</key2>
  </meta>
</Record1>
=end output


=begin code :lang<raku>
use LibXML::Class;
use Test::Async;

class Record2 is xml-element( :ns<http://my.namespace> ) {
    has Int:D $.id is required is xml-attribute;
    has Str:D $.description is required is xml-attribute;
    has Str $.comment is xml-element(:value-attr<text>, :ns( :extra ) );
    has Real:D $.amount is required is xml-element;
    has DateTime $.when; # Not part of XML
}

class METAEntry is xml-element {
    has Str:D $.key is required;
    has Str:D $.value is required;
}

role META is xml-element {
    has METAEntry @.meta-entry is xml-element('entry', :container<meta>);
}

class Registry is xml-element('registry', :ns( :extra<http://additional.namespace> )) does META {
    has Record2 @.record is xml-element;
}

my $root = Registry.new;
$root.record.append:
    Record2.new( :id(1001),
                 :description("item1"),
                 :comment("here comes a comment"),
                 :amount(42.12) ),
    Record2.new( :id(1002),
                 :description("item2"),
                 :amount(0) );

$root.meta-entry.append:
    METAEntry.new(:key<version>, :value<1.1a>),
    METAEntry.new(:key<encoding>, :value<utf-8>);

my $xml = $root.to-xml;

diag $xml.Str(:format);

my $root-copy = Registry.from-xml: $xml.Str;

cmp-deeply $root-copy, $root, "both are the same";
=end code


=begin output
# <?xml version="1.0" encoding="UTF-8"?>
# <registry xmlns:extra="http://additional.namespace">
#   <record xmlns="http://my.namespace" id="1001" description="item1">
#     <extra:comment text="here comes a comment"/>
#     <amount>42.12</amount>
#   </record>
#   <record xmlns="http://my.namespace" id="1002" description="item2">
#     <amount>0</amount>
#   </record>
#   <meta>
#     <entry key="version" value="1.1a"/>
#     <entry key="encoding" value="utf-8"/>
#   </meta>
# </registry>
#
ok 1 - both are the same
1..1
=end output


Primary documentation for this module can be found in L<C<LibXML::Class::Manual>|Class/Manual.md>. Here we would only
focus on a couple of technical details.


Whereas serialization is not that complex, after all, deserialization proves to be much trickier, espcially when it
comes to implementing lazy operations. The information in this section would only prove useful if you plan to somehow
"participate" in this party.


Deserialization is split into two major steps. The first one is building a profile for object constructor. At this step
we only know our outer deserialization context (think of it as if we know about our parent and how it is deserializing),
the current element we're about to deserialize, and the target class, an instance of which will represent the element
in Raku. When profile building is done (i.e. we have a C<%profile> hash with all necessary keys) we instantiate the
class using its C<xml-create> method:


=begin code :lang<raku>
TargetClass.xml-create: |%profile
=end code


The second step is not clearly localized in time as it might happen when the profile is being built, or later (up to
never at all) if lazy operations are in effect. Either way, this step is about the I<actual> deserialization from the
XML source. It takes place individually for every entity like attribute of sequence item.


Internally we use a couple of classes and roles that are used to produce an C<xml-element> out of user's type object.
These must not normally be of any concern. If an XMLized object is to be distinguished from other objects one can
test it against L<C<LibXML::Class::XML>|Class/XML.md> role.


Yet, on a rare occasion it might be needed to distinguish an XML sequence from a non-sequence. For this purpose it is
recommended to rely on typechecking against C<LibXML::Class::XMLSequential> role alone. Otherwise no warranties would
be given with regard to what parents and what roles an C<xml-element> is built of.


A few attributes that C<xml-element> trait would introduce onto your XMLized type object that might be useful on
occasion.


I<Note> that attributes listed here are actually private. Public access to them is provided via plain old methods.


The serialization and deserialization processes are, apparently, very much context-dependent. Therefore a couple of
dynamic variables are used to maintain and provide current context state.


Methods available on an C<xml-element>-traited class.


Methods Available For XML Sequence Types


Sequence types provide basic methods one would expect for L<C<Positional>|https://docs.raku.org/type/Positional> and
L<C<Iterable>|https://docs.raku.org/type/Iterable>. If a traditional method is not implemented then either it isn't
compatible with XML sequences or it could be implemented in the future; perhaps, by a request.


This module exports the following traits:


They're documented in L<C<LibXML::Class::Manual>|Class/Manual.md>.


This is just a shortcut for throwing a control exception which causes user-provided de-/serializer code to give up
and let the module do the job. See more details in the L<C<Manual>|Class/Manual.md>.


Cloning a deserialized object isn't a trivial task, especiall when lazy operations are in effect. A custom C<clone>
method overrides Raku's default which does some preparation before calling the parent method. When done C<post-clone>
method gets invoked. The default post-clone procedure includes registering a new deserialization for the source XML
element.


Class

The Raku Knowledge Base


=begin React :component<HeaderCol> :id<footer>  
=begin nested :!nested
=item1 B<Language>
    =item2 L<Get started|file:../getting-started/getting-started.podlite>
    =item2 L<Why Raku?|/doc/language/faq#Why-should-I-learn-Raku-What's-so-great-about-it>
    =item2 L<Try Raku|https://glot.io/new/raku>
    =item2 L<Raku cheat sheet|https://github.com/Raku/mu/blob/master/docs/Perl6/Cheatsheet/cheatsheet.txt>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<Raku on Exercism|https://exercism.org/tracks/raku>
    =item2 L<Wikipedia|https://en.wikipedia.org/wiki/Raku_(programming_language)>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>

=end nested
=begin nested :!nested

=item1 B<L<Documentation|/doc>>
    =item2 L<Getting started, Migration guides from other languages, & Tutorials | file:../doc/introduction.podlite>
    =item2 L<Language References|file:../doc/reference.podlite>
    =item2 L<Type Reference| file:../doc/types.podlite>
    =item2 L<Miscellaneous| file:../doc/miscellaneous.podlite>
    =item2 L<FAQs (Frequently Asked Questions)|/doc/language/faq>
    =item2 L<Community|/doc/language/community>
    =item2 L<The list of all documents|file:../doc/index.podlite>

=item1 B<Resources>
    =item2 L<The Raku Guide|https://raku.guide/>
    =item2 L<Books |https://perl6book.com/>
    =item2 L<Rosetta Code | https://www.raku.org/community/rosettacode>

=end nested
=begin nested :!nested

=item1 B<Resoures>
    =item2 L<Download | file:../download/index.podlite>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>

=item1 B<Learning>
    =item2 L<The Raku Guide|https://raku.guide/>
    =item2 L<Wikibook |https://en.wikibooks.org/wiki/Raku_Programming>
    =item2 L<Books |https://perl6book.com/>
    =item2 L<Rosetta Code | https://www.raku.org/community/rosettacode>
    =item2 L<Learn Raku in Y minutes|https://learnxinyminutes.com/docs/raku/>
    =item2 L<Golfing |https://github.com/AlexDaniel/raku-golf-cheatsheet>
=end nested
=begin nested :!nested

=item1 B<Explore>
    =item2 L<Raku Blog Aggregator|https://planet.raku.org/>
    =item2 L<Rakudo Weekly|https://rakudoweekly.blog/>
    =item2 L<The Weekly Challenge |https://perlweeklychallenge.org/>
    =item2 L<Raku Advent Calendar|https://raku-advent.blog/>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>

=end nested
=end React


=begin React :component<CookieConsent> :id<CookieConsent> :buttonCaption("Got it!")
=para
This website uses cookies for analytics.
=end React


Attr

NAME `LibXML::Class::Attr` - collection of attribute descriptors

DESCRIPTION

SEE ALSO

COPYRIGHT

LICENSE

LibXML::Class v0.0.1

Authors

License

Dependencies

Test Dependencies

Provides

Documentation

NAME LibXML::Class::Attr - collection of attribute descriptors