view release on metacpan or search on metacpan
lib/XBase/Index.pm view on Meta::CPAN
(this -type option may not work with all index formats at the moment
-- will be fixed and patches always welcome).
You can use C<-ddebug> option to indexdump to see how pages are
fetched and decoded, or run debugger to see the calls and parsing.
=head2 Using the index files to speed up searches in dbf
The syntax for using the index files to access data in the dbf file is
generally
view release on metacpan or search on metacpan
cci-src/src/cci/cci_handle_mng.c view on Meta::CPAN
for (i = 0; i < fetched_tuple; i++)
{
#if defined(WINDOWS)
for (j = 0; j < req_handle->num_col_info; j++)
{
FREE_MEM (req_handle->tuple_value[i].decoded_ptr[j]);
}
FREE_MEM (req_handle->tuple_value[i].decoded_ptr);
#endif
FREE_MEM (req_handle->tuple_value[i].column_ptr);
}
FREE_MEM (req_handle->tuple_value);
}
view release on metacpan or search on metacpan
lib/DBD/mysql.pm view on Meta::CPAN
$sth->bind_param(2, $byte_param, DBI::SQL_BINARY); # set correct binary type
$sth->execute();
my $output = $sth->fetchall_arrayref();
# returned data in $output reference should be already UTF-8 decoded as appropriate
=item mysql_enable_utf8mb4
This is similar to mysql_enable_utf8, but is capable of handling 4-byte
UTF-8 characters.
view release on metacpan or search on metacpan
lib/DBGp/Client/Response.pod view on Meta::CPAN
=item type
=item content
decoded content
=back
=head2 notify
lib/DBGp/Client/Response.pod view on Meta::CPAN
It always returns C<0> unless C<children> is true
=item value
The decoded value of scalar properties (typically useful when
C<children> is false).
=item childs
Array of C<DBGp::Client::Response::Property> objects. Returns an empty
view release on metacpan or search on metacpan
ex/unicode_test.pl view on Meta::CPAN
# NOTE: some DBs may uppercase table names
sub find_table {
my ($h, $table) = @_;
# won't find a match if the returned data is not utf8 decoded
my $s = $h->table_info(undef, undef, undef, 'TABLE');
my $r = $s->fetchall_arrayref;
my $found = first { $_->[2] =~ /$table/i} @$r;
ok($found, 'unicode table found in unqualified table_info');
SKIP: {
skip "table found via table_info", 1 if $found;
$found = first { Encode::decode_utf8($_->[2]) =~ /$table/i} @$r;
ok(!$found, "Table not found initially but when table name decoded it was found as $table");
};
my $found_some_utf8_tables;
foreach ($r) {
$found_some_utf8_tables++ if Encode::is_utf8($_->[2]);
}
view release on metacpan or search on metacpan
lib/DBIx/Class/EncodeColumns.pm view on Meta::CPAN
=head1 METHODS
=head2 decode_columns($encoding)
Use this function to set the default encoding of all your columns.
The data of all columns will be decoded to internal encoding of perl.
=cut
=head2 encode_columns($encoding)
view release on metacpan or search on metacpan
lib/DBIx/Class/UTF8Columns.pm view on Meta::CPAN
$self->next::method( $column, $value );
return $copy || $value;
}
# override this if you want to force everything to be encoded/decoded
sub _is_utf8_column {
# my ($self, $col) = @_;
return ($_[0]->utf8_columns || {})->{$_[1]};
}
view release on metacpan or search on metacpan
lib/DBIx/Oracle/Unwrap.pm view on Meta::CPAN
=head1 METHODS
=cut
# this is the substituion table. All the characters in the base64 decoded text
# must be replaced with its lookup
Readonly::Array my @sub_table => (
0x3d, 0x65, 0x85, 0xb3, 0x18, 0xdb, 0xe2, 0x87, 0xf1, 0x52, 0xab, 0x63,
0x4b, 0xb5, 0xa0, 0x5f, 0x7d, 0x68, 0x7b, 0x9b, 0x24, 0xc2, 0x28, 0x67,
lib/DBIx/Oracle/Unwrap.pm view on Meta::CPAN
my $text = shift;
return unless $text;
# Decode text and ignore the SHA1 hash (first 20 characters)
my $decoded = substr(decode_base64($text), 20, length($text) - 1);
return unless $decoded;
my ($zipped, $source);
#Translate each character
foreach my $byte (split //, $decoded) {
$zipped .= chr($sub_table[ord($byte)]);
}
# Uncompress (inflate) the data
my $status = inflate \$zipped => \$source
view release on metacpan or search on metacpan
lib/DBIx/QuickORM/Type/JSON.pm view on Meta::CPAN
sub qorm_compare {
my $class = shift;
my ($a, $b) = @_;
# First decode the json if it is not already decoded
$a = $class->qorm_inflate($a);
$b = $class->qorm_inflate($b);
# Now encode it in canonical form so that identical structures produce identical strings.
# Another option would be to use Test2::Compare...
view release on metacpan or search on metacpan
Revision history for Perl extension DBIx-Schema-Annotate
0.06 2015-05-26T08:48:55Z
- table ddl acquired from database is decoded
0.05 2015-05-21T06:07:10Z
- not do anything if there is no difference
view release on metacpan or search on metacpan
lib/DBIx/Squirrel/Crypt/Fernet.pm view on Meta::CPAN
$obj = DBIx::Squirrel::Crypt::Fernet->new($key);
A constructor (also see L<Fernet>).
If no arguments are passed then a random 32-byte Fernet key is generated. If
a Base64-encoded key is passed then it will be decoded and its signing and
encryption key fields extracted.
Take care never to display the binary signing and extraction keys, but to use
the C<to_string> method (or stringification) to recombine them into a Base64-
encoded Fernet key.
lib/DBIx/Squirrel/Crypt/Fernet.pm view on Meta::CPAN
Alternative constructor (also see L<new>).
Returns a new C<DBIx::Squirrel::Crypt::Fernet> object.
If no arguments are passed then a random 32-byte Fernet key is generated. If
a Base64-encoded key is passed then it will be decoded and its signing and
encryption key fields extracted.
Take care never to display the binary signing and extraction keys, but to use
the C<to_string> method (or stringification) to recombine them into a Base64-
encoded Fernet key.
view release on metacpan or search on metacpan
Another use is a simple database extraction tool, which is included, called sql2xml.
This tool simply dumps a table in a database to an XML file. This can be used in
conjunction with xml2sql (part of the XML::DBI(?) package) to transfer databases
from one platform or database server to another.
Binary data is encoded using UTF-8. This is automatically decoded when parsing
with XML::Parser.
Included with the distribution is a "Scriptlet" - this is basically a Win32 OLE
wrapper around this class, allowing you to call this module from any application
that supports OLE. To install it, first install the scriptlets download from
view release on metacpan or search on metacpan
lib/DDC/Client.pm view on Meta::CPAN
my $msg = join('',@_);
$msg = encode($dc->{encoding},$msg) if ($dc->{encoding} && utf8::is_utf8($msg));
return pack($ifmt,length($msg)) . $msg;
}
## $decoded = $dc->ddc_decode($response_buf)
sub ddc_decode {
my $dc = shift;
my $buf = unpack("$ifmt/a*",$_[0]);
$buf = decode($dc->{encoding},$buf) if ($dc->{encoding});
return $buf;
view release on metacpan or search on metacpan
XS/CQuery.pod view on Meta::CPAN
to the latter.
=head1 KNOWN BUGS
Objects should be transparently encoded/decoded to and from perl hash representations.
=head1 SEE ALSO
perl(1),
DDC::XS(3perl),
view release on metacpan or search on metacpan
lib/DDCCI.pm view on Meta::CPAN
# create a new object, using first found monitor
my $ddcci = DDCCI->new($monitors->[0]->{'dev'});
# get monitor EDID and decode it
my $edid = $ddcci->read_edid();
my $decoded = decode_edid($edid);
print "id: $decoded->{'id'}, s/n: $decoded->{'sn'}, type: $decoded->{'type'}\n";
# get monitor capabilities (from the firmware)
my $caps = $ddcci->read_caps();
print "Monitor capabilities: $cap\n";
view release on metacpan or search on metacpan
my $data = decode_djson $djson_string;
DESCRIPTION
DJSON is a data language that is simlar to JSON, just more chill. All
valid JSON is also valid DJSON (and represents the same thing when
decoded), but DJSON lets you omit a lot of the syntax that makes JSON a
pain to write.
DJSON SYNTAX
Here is some examples of DJSON followed by equivalent JSON:
view release on metacpan or search on metacpan
t/lib/djabberd-test.pl view on Meta::CPAN
warn "challenge response: [$challenge]\n" if $ENV{TESTDEBUG};
die "Didn't get expected response: $challenge" unless $challenge =~ /challenge|success\b/;
if ($challenge =~ s/^.*>(.+)<.*$/$1/sm) {
$challenge = decode_base64($challenge);
warn "decoded challenge: [$challenge]\n" if $ENV{TESTDEBUG};
}
my $response = $conn->client_step($challenge);
if ($conn->is_success) {
$got_success_already = 1;
view release on metacpan or search on metacpan
src/dmidecode.c view on Meta::CPAN
data=next;
i++;
}
if(i!=num)
printf("Wrong DMI structures count: %d announced, only %d decoded.\n",
num, i);
if(data-buf!=len)
printf("Wrong DMI structures length: %d bytes announced, structures occupy %d bytes.\n",
len, (unsigned int)(data-buf));
view release on metacpan or search on metacpan
lib/DMTF/CIM/WSMan.pm view on Meta::CPAN
}
$ret .= "<p:".($prop->name).">".$val."</p:".($prop->name).">";
}
}
else {
my $decoded;
if(ref($val) eq 'ARRAY') {
$decoded=join('',@{$val});
}
else {
$decoded=$val;
}
$ret .= "<p:".($prop->name).">".encode_base64($decoded)."</p:".($prop->name).">";
}
}
elsif(ref($val) eq 'ARRAY') {
foreach my $value (@$val) {
if($prop->is_ref) {
lib/DMTF/CIM/WSMan.pm view on Meta::CPAN
&& defined $model->{qualifiers}{octetstring}
&& $model->{qualifiers}{octetstring} eq 'true') {
if(defined $model->{type}
&& $model->{type} eq 'uint8'
&& defined $model->{array}) {
my $decoded=decode_base64($twig->text);
return wantarray ? ($decoded, 'bytes') : $decoded;
}
if(defined $model->{type}
&& $model->{type} eq 'string'
&& defined $model->{array}) {
my $encoded=$twig->text;
view release on metacpan or search on metacpan
contrib/spamtrap view on Meta::CPAN
=item B<Understands various forms of complex complaints>
When deployed in an address used by users to report spam, will attempt
to find the spam headers within attachments, possibly including
decoded uuencoded and base64 parts. Multiple header sets can be
analyzed in a single complaint, which will be archived separatedly.
=item B<Keeps an index of spam samples>
An external index, maintained with L<MLDBM>, L<Storable> and
view release on metacpan or search on metacpan
lib/DNS/NIOS/Response.pm view on Meta::CPAN
sub content {
my $self = shift;
my $h;
try {
$h = from_json( $self->_http_response->decoded_content );
}
catch {
$h = $self->_http_response->decoded_content;
# For some reason <5.28 returns a quoted string during test
$h =~ s/^"|"$//g;
};
return $h;
lib/DNS/NIOS/Response.pm view on Meta::CPAN
Wether the request was successful
=head2 content
Response content as hashref. If the content for some reason cannot be converted,
it will return the decoded_content as is.
=head2 json
Return a json string.
view release on metacpan or search on metacpan
lib/DNS/PunyDNS.pm view on Meta::CPAN
my $req = new HTTP::Request( 'GET', $url );
my $response = $ua->request($req);
if ( $response->is_success ) {
my $content = $response->content;
my $decoded_content = XMLin( \$content, KeyAttr => 'domain' );
if ( $decoded_content->{'error'} ) {
$self->{'error'} = $decoded_content->{'error'};
}
return $decoded_content;
} else {
die "There was a problem with the request\n" . $response->status_line;
}
} ## end sub _get_it
view release on metacpan or search on metacpan
lib/DNS/Unbound.pm view on Meta::CPAN
B<NOTE:> Consider parsing L<DNS::Unbound::Result>’s C<answer_packet()>
as a more robust, albeit heavier, way to parse query result data.
L<Net::DNS::Packet> and L<AnyEvent::DNS>’s C<dns_unpack()> are two good
ways to parse DNS packets.
=head2 $decoded = decode_name($encoded)
Decodes a DNS name. Useful for, e.g., C<NS>, C<CNAME>, and C<PTR> query
results.
Note that this function’s return will normally include a trailing C<.>
view release on metacpan or search on metacpan
0.62 2012-04-29T10:56:44Z
- Add SnmpCpeAccessControl to Syminfo Contributor: Elliot
0.61 2011-10-03T21:58:40Z
- Fix RT70882: ServiceClassName need to be zero-terminated This is
optional in input data structure and removed/not visible in decoded tree
either
0.6004 2010-09-12T21:51:02Z
- Fix #61267: Encode::int() fails on 64b systems: 1234567890 >> 8 ==
72057594033105405 != 11954685
view release on metacpan or search on metacpan
mp_check_array(const char *cur, const char *end);
/**
* \brief Decode an array header from MsgPack \a data.
*
* All array members must be decoded after the header.
* \param data - the pointer to a buffer
* \return the number of elements in an array
* \post *data = *data + mp_sizeof_array(retval)
* \sa \link mp_encode_array() An usage example \endlink
*/
mp_check_map(const char *cur, const char *end);
/**
* \brief Decode a map header from MsgPack \a data.
*
* All map key-value pairs must be decoded after the header.
* \param data - the pointer to a buffer
* \return the number of key/value pairs in a map
* \post *data = *data + mp_sizeof_array(retval)
* \sa \link mp_encode_map() An usage example \endlink
*/
/**
* \brief Decode a string from MsgPack \a data
* \param data - the pointer to a buffer
* \param len - the pointer to save a string length
* \return a pointer to a decoded string
* \post *data = *data + mp_sizeof_str(*len)
* \sa mp_encode_binl
*/
MP_PROTO const char *
mp_decode_str(const char **data, uint32_t *len);
/**
* \brief Decode a binstring from MsgPack \a data
* \param data - the pointer to a buffer
* \param len - the pointer to save a binstring length
* \return a pointer to a decoded binstring
* \post *data = *data + mp_sizeof_str(*len)
* \sa mp_encode_binl
*/
MP_PROTO const char *
mp_decode_bin(const char **data, uint32_t *len);
mp_check_bool(const char *cur, const char *end);
/**
* \brief Decode a bool value from MsgPack \a data
* \param data - the pointer to a buffer
* \return a decoded bool value
* \post *data = *data + mp_sizeof_bool(retval)
*/
MP_PROTO bool
mp_decode_bool(const char **data);
view release on metacpan or search on metacpan
lib/DR/SunDown.pm view on Meta::CPAN
# $string and $data have the same utf8 flag
my $string = markdown2html $data;
utf8::decode( $data ) if utf8::is_utf8( $data );
# $string is decoded utf8
my $string = markdown2html $data;
=head1 DESCRIPTION
view release on metacpan or search on metacpan
lib/DR/Tarantool/Spaces.pm view on Meta::CPAN
The standard L<Tarantool|http://tarantool.org> types.
=item UTF8STR
The same as B<STR>, but the string is utf8-decoded
after it's received from the server.
=item INT & INT64
The same as B<NUM> and B<NUM64>, but contain signed values.
=item JSON
The field is encoded with L<JSON::XS> when putting
into a database, and decoded after is received back
from the server.
=back
=head1 METHODS
view release on metacpan or search on metacpan
t/010-tarantool-1.5/010-dr-tqueue.t view on Meta::CPAN
"urgent(data => arrayref)";
my $task5_t = $q->take(tube => 'utftube');
my $task4_t = $q->take(tube => 'utftube');
is_deeply $task4->data, $task4_t->data, 'Task and decoded utf data';
is_deeply $task5->data, $task5_t->data, 'Task and encoded utf data';
SKIP: {
my $task_unique1 = eval {
$q->put_unique(tube => 'utftube_unique',
view release on metacpan or search on metacpan
lib/DR/Tnt.pm view on Meta::CPAN
(L<DR::Tnt::Client::Coro> and L<DR::Tnt::Client::Sync>).
=item utf8
Default value is C<TRUE>. If C<TRUE>, driver will unpack all
strings as C<utf8>-decoded strings.
=back
=head2 Information attributes
view release on metacpan or search on metacpan
CAB/Format/XmlRpc.pm view on Meta::CPAN
## $fmt = CLASS_OR_OBJ->new(%args)
## + object structure:
## (
## ##-- input
## rxprs => $rpc_parser, ##-- RPC::XML::Parser object
## rxdata => $rpc_data, ##-- structured data as decoded by RPC::XML::Parser
##
## ##-- output
## docbuf => $doc, ##-- DTA::CAB::Document output buffer
## xprs => $xml_parser, ##-- XML::LibXML parser object
## level => $formatLevel, ##-- format level
CAB/Format/XmlRpc.pm view on Meta::CPAN
%args, %$fmt:
##-- input
rxprs => $rpc_parser, ##-- RPC::XML::Parser object
rxdata => $rpc_data, ##-- structured data as decoded by RPC::XML::Parser
##
##-- output
docbuf => $doc, ##-- DTA::CAB::Document output buffer
xprs => $xml_parser, ##-- XML::LibXML parser object
level => $formatLevel, ##-- format level