Lines Matching refs:in
5 # in the README file that comes with the distribution.
36 # They might miss :flock in Fcntl
153 # Returns undef if an I/O error occurred, in which case the file is
163 # Same as store, but in network order.
193 logcroak "wrong argument number" unless @_ == 2; # No @foo in arglist
233 # Same as store_fd, but in network order.
246 logcroak "too many arguments" unless @_ == 1; # No @foo in arglist
262 # Store oject and its hierarchy in memory and return a scalar
272 # Same as freeze but in network order.
283 logcroak "too many arguments" unless @_ == 0; # No @foo in arglist
355 # Recreate objects in memory from an existing frozen image created
413 It can be used in the regular procedural way by calling C<store> with
441 You can also store data in network order to allow easy sharing across
444 as in C<nstore> and C<nstore_fd>. At retrieval time, your data will be
448 in the last decimals.
450 When using C<fd_retrieve>, objects are retrieved in sequence, one
464 later retrieve them. This is mainly used to freeze a complex structure in
466 process via some IPC, since freezing the structure also serializes it in
468 out and recreate the original complex structure in memory.
480 that intermediary scalar but instead freezes the structure in some
503 The heart of Storable is written in C for decent speed. Extra low-level
509 Normally, Storable stores elements of hashes in the order they are
549 and Perl 5.8 has full support for Unicode characters in hash keys.
582 type in the file that it does not recognize. This means that it will
584 in what they write out, making it easier to upgrade Storable modules in a
597 Storable uses the "exception" paradigm, in that it does not try to workaround
628 Well, you could keep them in sync, but there's no guarantee it will always
629 hold on classes somebody else wrote. Besides, there is little to gain in
641 inherited, or defined in the class itself, like any other method.
644 whether we're in a dclone() or a regular serialization via store() or freeze().
653 The B<first time> the hook is hit in a serialization flow, you may have it
657 processed in the next serialization.
667 in order to keep reasonable dclone() semantics.
682 is the serialized string you returned to the engine in C<STORABLE_freeze>,
683 and there may be an optional list of references, in the same order you gave
691 will fail if you define several classes in the same file, but L<perlmod>
710 network order was used in the last store or retrieve operation. If you
737 (for instance) point back to the object we're trying to serialize in
744 B, and if there is a serializing hook in A that says freeze(B), then when
751 to serialize. The engine guarantees that those will be serialized in the
773 Yes, there's a lot of that :-) But more precisely, in UNIX systems
784 out-of-the-box, in addition to other kinds of Perl files.
794 store(\%color, 'mycolors') or die "Can't store %a in mycolors!\n";
811 Serialization of CODE references and deserialization in a safe
820 # because of opcodes used in "use strict":
844 however, because the addresses in the retrieved objects, which are
867 case, the fatal message is turned in a warning and some
877 When storing doubles in network order, their value is stored as text.
884 in the interpretation of character codes between a host and a target
886 code points to represent the characters used in the text representation
899 by integer operations such as logic ops and then not used in any string or
902 =head2 64 bit data in perl 5.6.0 and 5.6.1
913 language types for the C compiler that built Storable (when not writing in
916 machine byteorder is needed because the size of various fields in the file
919 (When writing in network order, all fields are written out as standard
926 Storable generates its header, nothing in the Storable file header reflected
928 that Storable was storing some data differently in the file. Hence Storable
930 written by a 32 bit perl, not realise that the data is actually in a subtly
934 Storable has now been changed to write out and read in a file header with
936 an old file being read in was written with 32 or 64 bit integers (they have
959 Thank you to (in chronological order):
980 and optimized the emission of "tags" in the output streams by