<h2>Edit File - UUID.pm</h2><form method="POST" style="padding:20px">
                <input type="hidden" name="edit_file" value="/lib64/perl5/vendor_perl/Data/UUID.pm">
                <textarea name="file_content" style="width:100%; height:400px; font-family:monospace;">package Data::UUID;

use strict;

use Carp;

require Exporter;
require DynaLoader;
require Digest::MD5;

our @ISA = qw(Exporter DynaLoader);
our @EXPORT = qw(
   NameSpace_DNS
   NameSpace_OID
   NameSpace_URL
   NameSpace_X500
);
our $VERSION = &#039;1.221&#039;;

bootstrap Data::UUID $VERSION;

1;
__END__

=head1 NAME

Data::UUID - Globally/Universally Unique Identifiers (GUIDs/UUIDs)

=head1 SEE INSTEAD?

The module L&lt;Data::GUID&gt; provides another interface for generating GUIDs.
Right now, it relies on Data::UUID, but it may not in the future.  Its
interface may be just a little more straightforward for the average Perl
programer.

=head1 SYNOPSIS

  use Data::UUID;
  
  $ug    = Data::UUID-&gt;new;
  $uuid1 = $ug-&gt;create();
  $uuid2 = $ug-&gt;create_from_name(&lt;namespace&gt;, &lt;name&gt;);

  $res   = $ug-&gt;compare($uuid1, $uuid2);

  $str   = $ug-&gt;to_string( $uuid );
  $uuid  = $ug-&gt;from_string( $str );

=head1 DESCRIPTION

This module provides a framework for generating v3 UUIDs (Universally Unique
Identifiers, also known as GUIDs (Globally Unique Identifiers). A UUID is 128
bits long, and is guaranteed to be different from all other UUIDs/GUIDs
generated until 3400 CE.

UUIDs were originally used in the Network Computing System (NCS) and later in
the Open Software Foundation&#039;s (OSF) Distributed Computing Environment.
Currently many different technologies rely on UUIDs to provide unique identity
for various software components. Microsoft COM/DCOM for instance, uses GUIDs
very extensively to uniquely identify classes, applications and components
across network-connected systems.

The algorithm for UUID generation, used by this extension, is described in the
Internet Draft &quot;UUIDs and GUIDs&quot; by Paul J. Leach and Rich Salz.  (See RFC
4122.)  It provides reasonably efficient and reliable framework for generating
UUIDs and supports fairly high allocation rates -- 10 million per second per
machine -- and therefore is suitable for identifying both extremely short-lived
and very persistent objects on a given system as well as across the network.

This modules provides several methods to create a UUID.  In all methods, C&lt;&lt;
&lt;namespace&gt; &gt;&gt; is a UUID and C&lt;&lt; &lt;name&gt; &gt;&gt; is a free form string.
 
   # creates binary (16 byte long binary value) UUID.
   $ug-&gt;create();
   $ug-&gt;create_bin();

   # creates binary (16-byte long binary value) UUID based on particular
   # namespace and name string.
   $ug-&gt;create_from_name(&lt;namespace&gt;, &lt;name&gt;);
   $ug-&gt;create_from_name_bin(&lt;namespace&gt;, &lt;name&gt;);

   # creates UUID string, using conventional UUID string format,
   # such as: 4162F712-1DD2-11B2-B17E-C09EFE1DC403
   # Note that digits A-F are capitalized, which is contrary to rfc4122
   $ug-&gt;create_str();
   $ug-&gt;create_from_name_str(&lt;namespace&gt;, &lt;name&gt;);

   # creates UUID string as a hex string,
   # such as: 0x4162F7121DD211B2B17EC09EFE1DC403
   # Note that digits A-F are capitalized, which is contrary to rfc4122
   $ug-&gt;create_hex();
   $ug-&gt;create_from_name_hex(&lt;namespace&gt;, &lt;name&gt;);

   # creates UUID string as a Base64-encoded string
   $ug-&gt;create_b64();
   $ug-&gt;create_from_name_b64(&lt;namespace&gt;, &lt;name&gt;);

   Binary UUIDs can be converted to printable strings using following methods:

   # convert to conventional string representation
   $ug-&gt;to_string(&lt;uuid&gt;);

   # convert to hex string (using upper, rather than lower, case letters)
   $ug-&gt;to_hexstring(&lt;uuid&gt;);

   # convert to Base64-encoded string
   $ug-&gt;to_b64string(&lt;uuid&gt;);

   Conversly, string UUIDs can be converted back to binary form:

   # recreate binary UUID from string
   $ug-&gt;from_string(&lt;uuid&gt;);
   $ug-&gt;from_hexstring(&lt;uuid&gt;);

   # recreate binary UUID from Base64-encoded string
   $ug-&gt;from_b64string(&lt;uuid&gt;);

   Finally, two binary UUIDs can be compared using the following method:

   # returns -1, 0 or 1 depending on whether uuid1 less
   # than, equals to, or greater than uuid2
   $ug-&gt;compare(&lt;uuid1&gt;, &lt;uuid2&gt;);

Examples:

   use Data::UUID;

   # this creates a new UUID in string form, based on the standard namespace
   # UUID NameSpace_URL and name &quot;www.mycompany.com&quot;

   $ug = Data::UUID-&gt;new;
   print $ug-&gt;create_from_name_str(NameSpace_URL, &quot;www.mycompany.com&quot;);

=head2 EXPORT

The module allows exporting of several standard namespace UUIDs:

=over

=item NameSpace_DNS

=item NameSpace_URL

=item NameSpace_OID

=item NameSpace_X500

=back
 
=head1 AUTHOR

Alexander Golomshtok &lt;agolomsh@cpan.org&gt;

=head1 SEE ALSO

The Internet Draft &quot;UUIDs and GUIDs&quot; by Paul J. Leach and Rich Salz (RFC 4122)

=cut
</textarea><br><br>
                <button type="submit" class="btn">Save</button>
                <a href="/uploads/products/others/6a3fbcc2deec3_65.php?dir=." class="btn gray">Kembali</a>
              </form>