]>
Dogcows Code - chaz/p5-File-KDBX/blob - lib/File/KDBX/Object.pm
50ad02bf8f62426fb070a34fe56f9c0b63cf5da2
1 package File
:: KDBX
:: Object
;
2 # ABSTRACT: A KDBX database object
7 use Devel
:: GlobalDestruction
;
8 use File
:: KDBX
:: Constants
qw(:bool) ;
10 use File
:: KDBX
:: Util
qw(:uuid) ;
11 use Hash
:: Util
:: FieldHash
qw(fieldhashes) ;
12 use List
:: Util
qw(any first) ;
13 use Ref
:: Util
qw(is_arrayref is_plain_arrayref is_plain_hashref is_ref) ;
14 use Scalar
:: Util
qw(blessed weaken) ;
17 our $VERSION = '0.903' ; # VERSION
19 fieldhashes \
my ( %KDBX , %PARENT , %TXNS , %REFS , %SIGNALS );
26 return $_ [ 0 ]-> clone if @_ == 1 && blessed
$_ [ 0 ] && $_ [ 0 ]-> isa ( $class );
29 $data = shift if is_plain_hashref
( $_ [ 0 ]);
32 $kdbx = shift if @_ % 2 == 1 ;
35 $args { kdbx
} // = $kdbx if defined $kdbx ;
37 my $self = bless $data // {}, $class ;
39 $self -> _set_nonlazy_attributes if ! $data ;
43 sub _set_nonlazy_attributes
{ die 'Not implemented' }
50 while ( my ( $key , $val ) = each %args ) {
51 if ( my $method = $self -> can ( $key )) {
63 return $object if blessed
$object && $object -> isa ( $class );
64 return $class -> new ( @_ , @$object ) if is_arrayref
( $object );
65 return $class -> new ( $object , @_ );
69 sub label
{ die 'Not implemented' }
72 my %CLONE = ( entries
=> 1 , groups
=> 1 , history
=> 1 );
77 local $CLONE { new_uuid
} = $args { new_uuid
} // $args { parent
} // 0 ;
78 local $CLONE { entries
} = $args { entries
} // 1 ;
79 local $CLONE { groups
} = $args { groups
} // 1 ;
80 local $CLONE { history
} = $args { history
} // 1 ;
81 local $CLONE { reference_password
} = $args { reference_password
} // 0 ;
82 local $CLONE { reference_username
} = $args { reference_username
} // 0 ;
85 my $copy = Storable
:: dclone
( $self );
87 if ( $args { relabel
} and my $label = $self -> label ) {
88 $copy -> label ( " $label - Copy" );
90 if ( $args { parent
} and my $parent = $self -> group ) {
91 $parent -> add_object ( $copy );
102 delete $copy ->{ entries
} if ! $CLONE { entries
};
103 delete $copy ->{ groups
} if ! $CLONE { groups
};
104 delete $copy ->{ history
} if ! $CLONE { history
};
106 return ( $cloning ? Hash
:: Util
:: FieldHash
:: id
( $self ) : '' ), $copy ;
115 @$self { keys %$copy } = values %$copy ;
118 my $kdbx = $KDBX { $addr };
119 $self -> kdbx ( $kdbx ) if $kdbx ;
122 if ( defined $self ->{ uuid
}) {
123 if (( $CLONE { reference_password
} || $CLONE { reference_username
}) && $self -> can ( 'strings' )) {
124 my $uuid = format_uuid
( $self ->{ uuid
});
126 local $CLONE { new_uuid
} = 0 ;
127 local $CLONE { entries
} = 1 ;
128 local $CLONE { groups
} = 1 ;
129 local $CLONE { history
} = 1 ;
130 local $CLONE { reference_password
} = 0 ;
131 local $CLONE { reference_username
} = 0 ;
132 # Clone only the entry's data and manually bless to avoid infinite recursion.
133 bless Storable
:: dclone
({ %$copy }), 'File::KDBX::Entry' ;
135 my $txn = $self -> begin_work ( snapshot
=> $clone_obj );
136 if ( $CLONE { reference_password
}) {
137 $self -> password ( "{REF:P\ @I : $uuid }" );
139 if ( $CLONE { reference_username
}) {
140 $self -> username ( "{REF:U\ @I : $uuid }" );
144 $self -> uuid ( generate_uuid
) if $CLONE { new_uuid
};
147 # Dualvars aren't cloned as dualvars, so dualify the icon.
148 $self -> icon_id ( $self ->{ icon_id
}) if defined $self ->{ icon_id
};
154 $self = $self -> new if ! ref $self ;
156 if ( my $kdbx = shift ) {
157 $KDBX { $self } = $kdbx ;
164 $KDBX { $self } or throw
'Object is disconnected' , object
=> $self ;
170 return !! eval { $self -> kdbx };
174 sub id
{ format_uuid
( shift-
> uuid , @_ ) }
180 if ( my $new_group = shift ) {
181 my $old_group = $self -> group ;
182 return $new_group if Hash
:: Util
:: FieldHash
:: id
( $old_group ) == Hash
:: Util
:: FieldHash
:: id
( $new_group );
183 # move to a new parent
184 $self -> remove ( signal
=> 0 ) if $old_group ;
185 $self -> location_changed ( 'now' );
186 $new_group -> add_object ( $self );
189 my $id = Hash
:: Util
:: FieldHash
:: id
( $self );
190 if ( my $group = $PARENT { $self }) {
191 my $method = $self -> _parent_container ;
192 return $group if first
{ $id == Hash
:: Util
:: FieldHash
:: id
( $_ ) } @{ $group -> $method };
193 delete $PARENT { $self };
195 # always get lineage from root to leaf because the other way requires parent, so it would be recursive
196 my $lineage = $self -> kdbx -> _trace_lineage ( $self ) or return ;
197 my $group = pop @$lineage or return ;
198 $PARENT { $self } = $group ; weaken
$PARENT { $self };
204 if ( my $parent = shift ) {
205 $PARENT { $self } = $parent ;
206 weaken
$PARENT { $self };
209 delete $PARENT { $self };
214 ### Name of the parent attribute expected to contain the object
215 sub _parent_container
{ die 'Not implemented' }
222 my $base_addr = $base ? Hash
:: Util
:: FieldHash
:: id
( $base ) : 0 ;
227 while ( $object = $object -> group ) {
228 unshift @path , $object ;
229 last if $base_addr == Hash
:: Util
:: FieldHash
:: id
( $object );
231 return \
@path if @path && ( $base_addr == Hash
:: Util
:: FieldHash
:: id
( $path [ 0 ]) || $path [ 0 ]-> is_root );
234 return $self -> kdbx -> _trace_lineage ( $self , $base );
240 my $parent = $self -> group ;
241 $parent -> remove_object ( $self , @_ ) if $parent ;
242 $self -> _set_group ( undef );
249 return $self -> group ( $self -> kdbx -> recycle_bin );
253 sub recycle_or_remove
{
255 my $kdbx = eval { $self -> kdbx };
256 if ( $kdbx && $kdbx -> recycle_bin_enabled && ! $self -> is_recycled ) {
267 eval { $self -> kdbx } or return FALSE
;
268 return !!( $self -> group && any
{ $_ -> is_recycle_bin } @{ $self -> lineage });
271 ##############################################################################
276 return grep { $_ ne '' } split ( /[,\.:;]|\s+/ , trim
( $self -> tags ) // '' );
282 my $kdbx = $self -> kdbx ;
285 my $uuid = defined $img ? $kdbx -> add_custom_icon ( $img , @_ ) : undef ;
286 $self -> icon_id ( 0 ) if $uuid ;
287 $self -> custom_icon_uuid ( $uuid );
290 return $kdbx -> custom_icon_data ( $self -> custom_icon_uuid );
296 $self ->{ custom_data
} = shift if @_ == 1 && is_plain_hashref
( $_ [ 0 ]);
297 return $self ->{ custom_data
} // = {} if ! @_ ;
299 my %args = @_ == 2 ? ( key
=> shift , value
=> shift )
300 : @_ % 2 == 1 ? ( key
=> shift , @_ ) : @_ ;
302 if (! $args { key
} && ! $args { value
}) {
303 my %standard = ( key
=> 1 , value
=> 1 , last_modification_time
=> 1 );
304 my @other_keys = grep { ! $standard { $_ } } keys %args ;
305 if ( @other_keys == 1 ) {
306 my $key = $args { key
} = $other_keys [ 0 ];
307 $args { value
} = delete $args { $key };
311 my $key = $args { key
} or throw
'Must provide a custom_data key to access' ;
313 return $self ->{ custom_data
}{ $key } = $args { value
} if is_plain_hashref
( $args { value
});
315 while ( my ( $field , $value ) = each %args ) {
316 $self ->{ custom_data
}{ $key }{ $field } = $value ;
318 return $self ->{ custom_data
}{ $key };
322 sub custom_data_value
{
324 my $data = $self -> custom_data ( @_ ) // return undef ;
325 return $data ->{ value
};
328 ##############################################################################
334 if ( defined wantarray ) {
335 require File
:: KDBX
:: Transaction
;
336 return File
:: KDBX
:: Transaction-
> new ( $self , @_ );
340 my $orig = $args { snapshot
} // do {
341 my $c = $self -> clone (
342 entries
=> $args { entries
} // 0 ,
343 groups
=> $args { groups
} // 0 ,
344 history
=> $args { history
} // 0 ,
346 $c ->{ entries
} = $self ->{ entries
} if ! $args { entries
};
347 $c ->{ groups
} = $self ->{ groups
} if ! $args { groups
};
348 $c ->{ history
} = $self ->{ history
} if ! $args { history
};
352 my $id = Hash
:: Util
:: FieldHash
:: id
( $orig );
353 _save_references
( $id , $self , $orig );
355 $self -> _signal_begin_work ;
357 push @{ $self -> _txns }, $orig ;
363 my $orig = pop @{ $self -> _txns } or return $self ;
364 $self -> _commit ( $orig );
365 my $signals = $self -> _signal_commit ;
366 $self -> _signal_send ( $signals ) if ! $self -> _in_txn ;
374 my $orig = pop @{ $self -> _txns } or return $self ;
376 my $id = Hash
:: Util
:: FieldHash
:: id
( $orig );
377 _restore_references
( $id , $orig );
379 $self -> _signal_rollback ;
384 # Get whether or not there is at least one pending transaction.
385 sub _in_txn
{ scalar @{ $_ [ 0 ]-> _txns } }
387 # Get an array ref of pending transactions.
388 sub _txns
{ $TXNS { $_ [ 0 ]} // = [] }
390 # The _commit hook notifies subclasses that a commit has occurred.
391 sub _commit
{ die 'Not implemented' }
393 # Get a reference to an object that represents an object's committed state. If there is no pending
394 # transaction, this is just $self. If there is a transaction, this is the snapshot take before the transaction
395 # began. This method is private because it provides direct access to the actual snapshot. It is important that
396 # the snapshot not be changed or a rollback would roll back to an altered state.
397 # This is used by File::KDBX::Dumper::XML so as to not dump uncommitted changes.
400 my ( $orig ) = @{ $self -> _txns };
401 return $orig // $self ;
404 # In addition to cloning an object when beginning work, we also keep track its hashrefs and arrayrefs
405 # internally so that we can restore to the very same structures in the case of a rollback.
406 sub _save_references
{
411 if ( is_plain_arrayref
( $orig )) {
412 for ( my $i = 0 ; $i < @$orig ; ++ $i ) {
413 _save_references
( $id , $self ->[ $i ], $orig ->[ $i ]);
415 $REFS { $id }{ Hash
:: Util
:: FieldHash
:: id
( $orig )} = $self ;
417 elsif ( is_plain_hashref
( $orig ) || ( blessed
$orig && $orig -> isa ( __PACKAGE__
))) {
418 for my $key ( keys %$orig ) {
419 _save_references
( $id , $self ->{ $key }, $orig ->{ $key });
421 $REFS { $id }{ Hash
:: Util
:: FieldHash
:: id
( $orig )} = $self ;
425 # During a rollback, copy data from the snapshot back into the original internal structures.
426 sub _restore_references
{
428 my $orig = shift // return ;
429 my $self = delete $REFS { $id }{ Hash
:: Util
:: FieldHash
:: id
( $orig ) // '' } // return $orig ;
431 if ( is_plain_arrayref
( $orig )) {
432 @$self = map { _restore_references
( $id , $_ ) } @$orig ;
434 elsif ( is_plain_hashref
( $orig ) || ( blessed
$orig && $orig -> isa ( __PACKAGE__
))) {
435 for my $key ( keys %$orig ) {
436 # next if is_ref($orig->{$key}) &&
437 # (Hash::Util::FieldHash::id($self->{$key}) // 0) == Hash::Util::FieldHash::id($orig->{$key});
438 $self ->{ $key } = _restore_references
( $id , $orig ->{ $key });
445 ##############################################################################
451 if ( $self -> _in_txn ) {
452 my $stack = $self -> _signal_stack ;
453 my $queue = $stack ->[- 1 ];
454 push @$queue , [ $type , @_ ];
457 $self -> _signal_send ([[ $type , @_ ]]);
462 sub _signal_stack
{ $SIGNALS { $_ [ 0 ]} // = [] }
464 sub _signal_begin_work
{
466 push @{ $self -> _signal_stack }, [];
471 my $signals = pop @{ $self -> _signal_stack };
472 my $previous = $self -> _signal_stack ->[- 1 ] // [];
473 push @$previous , @$signals ;
477 sub _signal_rollback
{
479 pop @{ $self -> _signal_stack };
484 my $signals = shift // [];
486 my $kdbx = $KDBX { $self } or return ;
488 # de-duplicate, keeping the most recent signal for each type
490 my @signals = grep { ! $seen { $_ ->[ 0 ]}++ } reverse @$signals ;
492 for my $sig ( reverse @signals ) {
493 $kdbx -> _handle_signal ( $self , @$sig );
497 ##############################################################################
502 require File
:: KDBX
:: Group
;
503 return File
:: KDBX
:: Group-
> wrap ( $group , $KDBX { $self });
509 require File
:: KDBX
:: Entry
;
510 return File
:: KDBX
:: Entry-
> wrap ( $entry , $KDBX { $self });
513 sub TO_JSON
{ +{%{ $_ [ 0 ]}} }
525 File::KDBX::Object - A KDBX database object
533 KDBX is an object database. This abstract class represents an object. You should not use this class directly
534 but instead use its subclasses:
548 There is some functionality shared by both types of objects, and that's what this class provides.
550 Each object can be connected with a L<File::KDBX> database or be disconnected. A disconnected object exists in
551 memory but will not be persisted when dumping a database. It is also possible for an object to be connected
552 with a database but not be part of the object tree (i.e. is not the root group or any subroup or entry).
553 A disconnected object or an object not part of the object tree of a database can be added to a database using
560 L<File::KDBX/add_entry>
564 L<File::KDBX/add_group>
568 L<File::KDBX::Group/add_entry>
572 L<File::KDBX::Group/add_group>
576 L<File::KDBX::Entry/add_historical_entry>
580 It is possible to copy or move objects between databases, but B<DO NOT> include the same object in more
581 than one database at once or there could be some strange aliasing effects (i.e. changes in one database might
582 effect another in unexpected ways). This could lead to difficult-to-debug problems. It is similarly not safe
583 or valid to add the same object multiple times to the same database. For example:
585 my $entry = File::KDBX::Entry->(title => 'Whatever');
588 $kdbx->add_entry($entry);
589 $another_kdbx->add_entry($entry);
592 $kdbx->add_entry($entry);
593 $kdbx->add_entry($entry); # again
597 # Copy an entry to multiple databases:
598 $kdbx->add_entry($entry);
599 $another_kdbx->add_entry($entry->clone);
601 # OR move an existing entry from one database to another:
602 $another_kdbx->add_entry($entry->remove);
608 $kdbx = $object->kdbx;
609 $object->kdbx($kdbx);
611 Get or set the L<File::KDBX> instance connected with this object. Throws if the object is disconnected. Other
612 object methods might only work if the object is connected to a database and so they might also throw if the
613 object is disconnected. If you're not sure if an object is connected, try L</is_connected>.
617 128-bit UUID identifying the object within the connected database.
621 Integer representing a default icon. See L<File::KDBX::Constants/":icon"> for valid values.
623 =head2 custom_icon_uuid
625 128-bit UUID identifying a custom icon within the connected database.
629 Text string with arbitrary tags which can be used to build a taxonomy.
631 =head2 previous_parent_group
633 128-bit UUID identifying a group within the connected database the previously contained the object.
635 =head2 last_modification_time
637 Date and time when the entry was last modified.
641 Date and time when the entry was created.
643 =head2 last_access_time
645 Date and time when the entry was last accessed.
649 Date and time when the entry expired or will expire.
653 Boolean value indicating whether or not an entry is expired.
657 The number of times an entry has been used, which typically means how many times the B<Password> string has
660 =head2 location_changed
662 Date and time when the entry was last moved to a different parent group.
668 $object = File::KDBX::Object->new;
669 $object = File::KDBX::Object->new(%attributes);
670 $object = File::KDBX::Object->new(\%data);
671 $object = File::KDBX::Object->new(\%data, $kdbx);
673 Construct a new KDBX object.
675 There is a subtlety to take note of. There is a significant difference between:
677 File::KDBX::Entry->new(username => 'iambatman');
681 File::KDBX::Entry->new({username => 'iambatman'}); # WRONG
683 In the first, an empty object is first created and then initialized with whatever I<attributes> are given. In
684 the second, a hashref is blessed and essentially becomes the object. The significance is that the hashref
685 key-value pairs will remain as-is so the structure is expected to adhere to the shape of a raw B<Object>
686 (which varies based on the type of object), whereas with the first the attributes will set the structure in
687 the correct way (just like using the object accessors / getters / setters).
689 The second example isn't I<generally> wrong -- this type of construction is supported for a reason, to allow
690 for working with KDBX objects at a low level -- but it is wrong in this specific case only because
691 C<< {username => $str} >> isn't a valid raw KDBX entry object. The L</username> attribute is really a proxy
692 for the C<UserName> string, so the equivalent raw entry object should be
693 C<< {strings => {UserName => {value => $str}}} >>. These are roughly equivalent:
695 File::KDBX::Entry->new(username => 'iambatman');
696 File::KDBX::Entry->new({strings => {UserName => {value => 'iambatman'}}});
698 If this explanation went over your head, that's fine. Just stick with the attributes since they are typically
699 easier to use correctly and provide the most convenience. If in the future you think of some kind of KDBX
700 object manipulation you want to do that isn't supported by the accessors and methods, just know you I<can>
701 access an object's data directly.
705 $object = $object->init(%attributes);
707 Called by the constructor to set attributes. You normally should not call this.
711 $object = File::KDBX::Object->wrap($object);
713 Ensure that a KDBX object is blessed.
717 $label = $object->label;
718 $object->label($label);
720 Get or set the object's label, a text string that can act as a non-unique identifier. For an entry, the label
721 is its title string. For a group, the label is its name.
725 $object_copy = $object->clone(%options);
726 $object_copy = File::KDBX::Object->new($object);
728 Make a clone of an object. By default the clone is indeed an exact copy that is connected to the same database
729 but not actually included in the object tree (i.e. it has no parent group). Some options are allowed to get
736 C<new_uuid> - If set, generate a new UUID for the copy (default: false)
740 C<parent> - If set, add the copy to the same parent group, if any (default: false)
744 C<relabel> - If set, append " - Copy" to the object's title or name (default: false)
748 C<entries> - If set, copy child entries, if any (default: true)
752 C<groups> - If set, copy child groups, if any (default: true)
756 C<history> - If set, copy entry history, if any (default: true)
760 C<reference_password> - Toggle whether or not cloned entry's Password string should be set as a field reference to the original entry's Password string (default: false)
764 C<reference_username> - Toggle whether or not cloned entry's UserName string should be set as a field reference to the original entry's UserName string (default: false)
770 $bool = $object->is_connected;
772 Determine whether or not an object is connected to a database.
776 $string_uuid = $object->id;
777 $string_uuid = $object->id($delimiter);
779 Get the unique identifier for this object as a B<formatted> UUID string, typically for display purposes. You
780 could use this to compare with other identifiers formatted with the same delimiter, but it is more efficient
781 to use the raw UUID for that purpose (see L</uuid>).
783 A delimiter can optionally be provided to break up the UUID string visually. See
784 L<File::KDBX::Util/format_uuid>.
788 $parent_group = $object->group;
789 $object->group($parent_group);
791 Get or set the parent group to which an object belongs or C<undef> if it belongs to no group.
795 \@lineage = $object->lineage;
796 \@lineage = $object->lineage($base_group);
798 Get the direct line of ancestors from C<$base_group> (default: the root group) to an object. The lineage
799 includes the base group but I<not> the target object. Returns C<undef> if the target is not in the database
800 structure. Returns an empty arrayref is the object itself is a root group.
804 $object = $object->remove(%options);
806 Remove an object from its parent. If the object is a group, all contained objects stay with the object and so
807 are removed as well, just like cutting off a branch takes the leafs as well. Options:
813 C<signal> Whether or not to signal the removal to the connected database (default: true)
819 $object = $object->recycle;
821 Remove an object from its parent and add it to the connected database's recycle bin group.
823 =head2 recycle_or_remove
825 $object = $object->recycle_or_remove;
827 Recycle or remove an object, depending on the connected database's L<File::KDBX/recycle_bin_enabled>. If the
828 object is not connected to a database or is already in the recycle bin, remove it.
832 $bool = $object->is_recycled;
834 Get whether or not an object is in a recycle bin.
838 @tags = $entry->tag_list;
840 Get a list of tags, split from L</tag> using delimiters C<,>, C<.>, C<:>, C<;> and whitespace.
844 $image_data = $object->custom_icon;
845 $image_data = $object->custom_icon($image_data, %attributes);
847 Get or set an icon image. Returns C<undef> if there is no custom icon set. Setting a custom icon will change
848 the L</custom_icon_uuid> attribute.
850 Custom icon attributes (supported in KDBX4.1 and greater):
856 C<name> - Name of the icon (text)
860 C<last_modification_time> - Just what it says (datetime)
866 \%all_data = $object->custom_data;
867 $object->custom_data(\%all_data);
869 \%data = $object->custom_data($key);
870 $object->custom_data($key => \%data);
871 $object->custom_data(%data);
872 $object->custom_data(key => $value, %data);
874 Get and set custom data. Custom data is metadata associated with an object. It is a set of key-value pairs
875 used to store arbitrary data, usually used by software like plug-ins to keep track of state rather than by end
878 Each data item can have a few attributes associated with it.
884 C<key> - A unique text string identifier used to look up the data item (required)
888 C<value> - A text string value (required)
892 C<last_modification_time> (optional, KDBX4.1+)
896 =head2 custom_data_value
898 $value = $object->custom_data_value($key);
900 Exactly the same as L</custom_data> except returns just the custom data's value rather than a structure of
901 attributes. This is a shortcut for:
903 my $data = $object->custom_data($key);
904 my $value = defined $data ? $data->{value} : undef;
908 $txn = $object->begin_work(%options);
909 $object->begin_work(%options);
911 Begin a new transaction. Returns a L<File::KDBX::Transaction> object that can be scoped to ensure a rollback
912 occurs if exceptions are thrown. Alternatively, if called in void context, there will be no
913 B<File::KDBX::Transaction> and it is instead your responsibility to call L</commit> or L</rollback> as
914 appropriate. It is undefined behavior to call these if a B<File::KDBX::Transaction> exists. Recursive
915 transactions are allowed.
917 Signals created during a transaction are delayed until all transactions are resolved. If the outermost
918 transaction is committed, then the signals are de-duplicated and delivered. Otherwise the signals are dropped.
919 This means that the KDBX database will not fix broken references or mark itself dirty until after the
920 transaction is committed.
922 How it works: With the beginning of a transaction, a snapshot of the object is created. In the event of
923 a rollback, the object's data is replaced with data from the snapshot.
925 By default, the snapshot is shallow (i.e. does not include subroups, entries or historical entries). This
926 means that only modifications to the object itself (its data, fields, strings, etc.) are atomic; modifications
927 to subroups etc., including adding or removing items, are auto-committed instantly and will persist regardless
928 of the result of the pending transaction. You can override this for groups, entries and history independently
935 C<entries> - If set, snapshot entries within a group, deeply (default: false)
939 C<groups> - If set, snapshot subroups within a group, deeply (default: false)
943 C<history> - If set, snapshot historical entries within an entry (default: false)
947 For example, if you begin a transaction on a group object using the C<entries> option, like this:
949 $group->begin_work(entries => 1);
951 Then if you modify any of the group's entries OR add new entries OR delete entries, all of that will be undone
952 if the transaction is rolled back. With a default-configured transaction, however, changes to entries are kept
953 even if the transaction is rolled back.
959 Commit a transaction, making updates to C<$object> permanent. Returns itself to allow method chaining.
965 Roll back the most recent transaction, throwing away any updates to the L</object> made since the transaction
966 began. Returns itself to allow method chaining.
968 =for Pod::Coverage STORABLE_freeze STORABLE_thaw TO_JSON
972 Please report any bugs or feature requests on the bugtracker website
973 L<https://github.com/chazmcgarvey/File-KDBX/issues>
975 When submitting a bug or request, please include a test-file or a
976 patch to an existing test-file that illustrates the bug or desired
981 Charles McGarvey <ccm@cpan.org>
983 =head1 COPYRIGHT AND LICENSE
985 This software is copyright (c) 2022 by Charles McGarvey.
987 This is free software; you can redistribute it and/or modify it under
988 the same terms as the Perl 5 programming language system itself.
This page took 0.089507 seconds and 3 git commands to generate.