CPAN::Groonga

owing methods:

=cut

=head2 decode

  decode(Str $data) : HashRef

The decode method decodes the JSON data provided and returns the data as a hashref.

=over 4

=item decode example #1

  # given: sy

encode

  encode(HashRef $data) : Str

The encode method encodes and returns the data provided as JSON.

=over 4

=item encode example #1

  # given: synopsis

  $temp->encode({ status => 'ok' });

=b

owing methods:

=cut

=head2 decode

  decode(Str $data) : HashRef

The decode method decodes the JSON data provided and returns the data as a hashref.

=over 4

=item decode example #1

  # given: sy

encode

  encode(HashRef $data) : Str

The encode method encodes and returns the data provided as JSON.

=over 4

=item encode example #1

  # given: synopsis

  $disk->encode({ status => 'ok' });

=b

1:6379,debug=0'

  # configure the object encoder (defaults to 'Zing::Encoder::Json')
  ZING_ENCODER='Zing::Encoder::Json'

  # configure where the command-line tool finds catridges and PID files
  ZI

ect to the guarantees and limitations of that underlying system.
Data serialization, e.g. L<JSON|https://json.org>, is also pluggable.

=back

=cut

=head1 AUTHOR

Al Newkirk, C<awncorp@cpan.org>

=he

owing methods:

=cut

=head2 decode

  decode(Str $data) : HashRef

The decode method decodes the JSON data provided and returns the data as a hashref.

=over 4

=item decode example #1

  # given: sy

encode

  encode(HashRef $data) : Str

The encode method encodes and returns the data provided as JSON.

=over 4

=item encode example #1

  # given: synopsis

  $hash->encode({ status => 'ok' });

=b

ub new {
  my $self = shift->SUPER::new(@_);

  # -json op
  push @{$self->{unary_ops}}, {
    regex   => qr/^json$/,
    handler => sub { '?', {json => $_[2]} }
  };

  return $self;
}

sub _insert_r

ostgreSQL features used by L<Mojo::Pg>.

=head2 JSON

In many places (as supported by L<SQL::Abstract>) you can use the C<-json> unary op to encode JSON from Perl data
structures.

  # "UPDATE some_ta

('some_table', {foo => {-json => [1, 2, 3]}}, {bar => 23});

  # "SELECT * FROM some_table WHERE foo = '[1,2,3]'"
  $abstract->select('some_table', '*', {foo => {'=' => {-json => [1, 2, 3]}}});

=head

ou may need to use a
different import syntax.

    use Test::JSON;                          # not ok
    use Test::JSON import => ['is_json'];    # ok

=head1 CONFIGURATION

By default, this policy ig

e Cwd;
use App::CSE::Colorizer;
use DateTime;
use File::MimeInfo::Magic;
use IO::Interactive;
use JSON;
use String::CamelCase;

use Path::Class::Dir;
use File::stat;
use Getopt::Long qw//;
use Regexp:

 unless( -r $self->index_meta_file() ){
    return { version => '-unknown-' };
  }
  return JSON::decode_json(File::Slurp::read_file($self->index_meta_file().'' , { binmode => ':raw' }));
}

sub _buil

s{
  my ($self) = @_;
  unless( -r $self->index_dirty_file() ){
    return {};
  }
  return JSON::decode_json(File::Slurp::read_file($self->index_dirty_file().'' , { binmode => ':raw' }));
}

sub _bui

package Data::QuickMemoPlus::Reader;
use 5.010;
use strict;
use warnings;
use Carp;
use JSON;
use Archive::Zip qw( :ERROR_CODES :CONSTANTS );

our $VERSION = "0.12";

use Exporter qw(import);
 
our @E

= $2;
    }
    my $json_str = extract_json_from_lqm( $lqm_file );
    
    return '' if not $json_str;
    
    my ($extracted_text, $note_category) = extract_text_from_json($json_str);
    my $heade

    
    return $header . $extracted_text;
}

#####################################
#
sub extract_json_from_lqm {
    my $lqm_file = shift;
    my $lqm_zip = Archive::Zip->new();
    unless ( $lqm_zip

ute handlers
use strict;
use warnings;
use Mojo::Base 'Mojolicious::Plugin';
use Mojo::JSON qw(decode_json to_json);
use GraphQL::Execution qw(execute);
use GraphQL::Type::Library -all;
use GraphQL::D

sub _safe_serialize {
  my $data = shift // return 'undefined';
  my $json = to_json($data);
  $json =~ s#/#\\/#g;
  return $json;
}

sub _graphiql_wrap {
  my ($wrappee, $use_subscription) = @_;
  s

variablesString  => _safe_serialize( $p->param('variables') ),
        subscriptionEndpoint => to_json(
          # if serialises to true (which empty-string will), turns on subs code
          $use_s

odule->status->extract;
    return if !$wrksrc;

    my $summary = q{};
    for (qw(META.yml META.json)) {
        my $metafile = catfile( $wrksrc, $_ );
        if ( -f $metafile ) {
            my $

a::Session::ID::UUID16> or UUID34 or UUID36 or UUD64

=back

=head1 JSON

L<Data::Session::Serialize::JSON> uses L<JSON>, not L<JSON::Syck>.

=head2 Managing Object Attributes

The light-weight L<Hash

alize::FreezeThaw>

=item o CGI::Session::Serialize::json becomes L<Data::Session::Serialize::JSON>

The latter will use L<JSON>. In the past L<JSON::Syck> was used.

=item o CGI::Session::Serialize::

nings;
use strict;

use Carp;
use Data::Dumper;
use File::Path qw(make_path);
use File::Spec;
use JSON;
use List::Util qw(first);
use Moo;
use MySQL::Workbench::Parser;

# ABSTRACT: create DBIC scheme

::upgrade( $comment );

    my $data;
    my $table_comment_perl = '';
    eval {
        $data = JSON->new->decode( $comment );
    };

    if ( !ref $data || 'HASH' ne ref $data ) {
        $data   

8::upgrade( $comment );

    my $data;
    my $view_comment_perl = '';
    eval {
        $data = JSON->new->decode( $comment );
    };

    if ( !ref $data || 'HASH' ne ref $data ) {
        $data   

opic;

use strict;
use warnings;

our $VERSION = '2.0';
use base qw(Amazon::SNS::V4::Topic);

use JSON;

# add messagegroupid and deduplicationid for FIFO
sub Publish
{
	my ($self, $msg, $subj, $group

 $structure = undef;
	my $attributes = undef;

	# support JSON payload
	if (ref($msg) eq 'HASH') {

		$structure = 'json';
		$msg = encode_json($msg);
	}

	if (defined($attr) and ref($attr) eq 'HASH')

t log injection
# - Make everything async (top priority)
# - Maybe allow something like ->feed_to_json (look at superfeedr)
# - Test ->discover

# Default lease seconds before automatic subscription r

hout checking its prereqs)
 % lcpan core-or-pp JSON::MaybeXS

 # Check that a module and its prereqs are all core/PP
 % lcpan core-or-pp --with-deps JSON::MaybeXS

 # Check that a module and its recur

PP
 % lcpan core-or-pp --with-recursive-deps JSON::MaybeXS

 # Check that a module and its prereqs are all core
 % lcpan core-or-pp --with-deps --core JSON::MaybeXS

 # Check that a module and its pre

reqs are all PP
 % lcpan core-or-pp --with-deps --pp JSON::MaybeXS

=head1 DESCRIPTION

This bundle provides the following lcpan subcommands:

=over

=item * L<lcpan core-or-pp|App::lcpan::Cmd::core_o

e JSON;

__PACKAGE__->mk_accessors(qw/ sns arn /);

sub Publish
{
	my ($self, $msg, $subj, $attr) = @_;

	# XXX croak on invalid arn

	my $structure = undef;
	my $attributes = undef;

	# support JSON 

payload
	if (ref($msg) eq 'HASH') {

		$structure = 'json';
		$msg = encode_json($msg);
	}

	if (defined($attr) and ref($attr) eq 'HASH') {

		my $i = 1;

		foreach my $key (keys %$attr) {

			$attrib

    = $q -> param($name);
	my($dir_name) = '/tmp';
	my($type)     = 'driver:File;id:MD5;serialize:JSON';
	my($session)  = Data::Session -> new
	(
		directory => $dir_name,
		name      => $name,
		quer

ons.

See L<Data::Session::Serialize::FreezeThaw>.

=item o JSON

Use L<JSON> to freeze/thaw sessions.

See L<Data::Session::Serialize::JSON>.

=item o Storable

Use L<Storable> to freeze/thaw session

DataDumper>

=item o L<Data::Session::Serialize::FreezeThaw>

=item o L<Data::Session::Serialize::JSON>

=item o L<Data::Session::Serialize::Storable>

Warning: Storable should be avoided until this p

red with 'eq' operator; if you have array
 # of records/structures, you can encode each record as JSON or using Data::Dmp,
 # for example)
 my @seq1 = qw(1 2 3 4 5 6);
 my @seq2 = qw(4 5 6 7 8 9);
 my

File::Spec::Functions/catfile> is used in reading the training data files.

=item JSON::Parse

L<JSON::Parse/read_json> is used to read in configuration information.

=item Unicode::Normalize

L<Unico

isance compared to Perl, and I've
found it's usually easier to convert the tables to JSON in Perl then
read the JSON into a C<map[string]string> in Go.

=head1 DEPENDENCIES

=over

=item Carp

L<Carp>