CPAN::Groonga

If you use that on structured data (like a JSON structure), this might render your
data invalid. For instance if you have a large base64 string in your JSON, it will be broken
by this. To avoid this 

er
controlled by a Brocade::BSC controller.

=cut

use strict;
use warnings;

use Data::Walk;
use JSON -convert_blessed_universally;

package Brocade::BSC::Node::NC::Vrouter::StaticRoute;

use parent 

_json>

  # Returns   : static route configuration as formatted JSON string.

=cut ===================================================================
sub as_json {
    my $self = shift;
    my $json 

= new JSON->canonical->allow_blessed->convert_blessed;
    return $json->pretty->encode($self);
}


# Subroutine ===========================================================
#             _strip_undef:

ation;
use File::Basename;
use File::Path;
use File::Slurp;
use HTML::Entities;
use IO::File;
use JSON;
use Time::Local;

use Metabase    0.004;
use Metabase::Fact;
use Metabase::Resource;
use CPAN::T

a::FlexSerializer->new(
        detect_compression  => 1,
        detect_json         => 1,
        output_format       => 'json'
    );
    $self->{serializer2} = Data::FlexSerializer->new(
        d

me = ref $fact;
        $facts{$name} = $fact->as_struct;
        $facts{$name}{content} = decode_json($facts{$name}{content});
    }

    return \%facts;
}

sub parse_report {
    my ($self,%hash) = 

SION = '0.0007';

use WebService::HipChat;
use Log::Dispatch::Output;
use Try::Tiny;
use JSON::XS qw/decode_json/;
 
use base qw( Log::Dispatch::Output );

use Params::Validate qw(validate SCALAR BOOL

            my $response = HTTP::Response->parse( $http_response );
            my $data = decode_json( $response->decoded_content );
            if( $data->{error}{message} ){
                die( sp

n - Queue like low-level interface for Gearman.

=head1 SYNOPSIS

    use Queue::Gearman;
    use JSON;

    sub add {
        my $args = shift;
        return $args->{left} + $args->{rigth};
    }

 

           => ['127.0.0.1:6667'],
        serialize_method   => \&JSON::encode_json,
        deserialize_method => \&JSON::decode_json,
    );
    $queue->can_do('add');

    my $task = $queue->enqueu

tworking controller.

=cut

package Brocade::BSC::Node;

use strict;
use warnings;

use YAML;
use JSON -convert_blessed_universally;

=head1 METHODS

=cut

# Constructor ==============================

===========
#
=item B<as_json>

  # Returns   : Returns pretty-printed JSON string representing netconf node.

=cut
sub as_json {
    my $self = shift;
    my $json = new JSON->canonical->allow_blesse

d->convert_blessed;
    return $json->pretty->encode($self);
}


# Method ===============================================================
#
=item B<ctrl_req>

  # Parameters: $method (string, req) HTT

F::FlowEntry;

use strict;
use warnings;

use Brocade::BSC::Node::OF::Match;

use Data::Walk;
use JSON -convert_blessed_universally;


# Package =======================================================

new Brocade::BSC::Node::OF::FlowEntry::Instructions;
    bless ($self, $class);
    # if ($params{json}) {
    #     die "foobar\n";
    # }
    if ($params{href}) {
        while (my ($key, $value) =

<as_json>

  # Returns   : FlowEntry as formatted JSON string.

=cut ===================================================================
sub as_json {
    my $self = shift;
    my $json = new JSON->ca

= @_) {
        $self->{vlan_id}->{vlan_id} = $vid;
        $self->{vlan_id}->{vlan_id_present} = JSON::true;
    }
    return $self->{vlan_id}->{vlan_id};
}
sub pcp {
    my ($self, $pcp) = @_;
    $

package Captcha::reCAPTCHA::V2;

use strict;
use warnings;

use Carp;
use HTTP::Tiny;
use JSON;

# ABSTRACT: A Perl implementation of reCAPTCHA API version 2

our $VERSION = '0.3'; # VERSION


sub new

ptcha_script {
    my ($self, $sitekey, $options) = @_;

    my $json_options = to_json({ sitekey => $sitekey, %$options }, $self->{json_options} || {});

    return '<script type="text/javascript">va

r onloadCallback = function(){grecaptcha.render(\''
        . _element_id($sitekey) . '\',' . $json_options . ');};</script>';
}


sub html {
    my ($self, $sitekey, $options) = @_;

    $options ||=

gexp::Common;   # balanced paren matching
use HTTP::Status qw(:constants :is status_message);
use JSON -convert_blessed_universally;

=head1 METHODS

=cut

# Constructor ==============================

s = $1) =~ s/flow-node-inventory:flow-feature-capability-//g);
        $feature_info_ref = decode_json($features);
        $status->code($BSC_OK);
    }
    else {
        $status->http_err($resp);
  

        my $node_connector_json = ($resp->content =~ /$RE{balanced}{-keep}{-begin => "\"node-connector\":\["}{-end => "]"}/ && $1);
        @port_list = ($node_connector_json =~ /\"flow-node-inventory

use common::sense;
use Carp;
use Scalar::Util qw(weaken);

use Log::Log4perl ();
use DBI ();
use JSON::XS ();

use AnyEvent ();
use AnyEvent::Util ();

use Lim ();

=encoding utf8

=head1 NAME

Lim::

%args = ( @_ );
    my $self = {
        logger => Log::Log4perl->get_logger($class),
        json => JSON::XS->new->utf8->convert_blessed,
        busy => 0
    };
    bless $self, $class;
    weaken

   $response = $self->{json}->incr_parse($buf);
                    };
                    if ($@) {
                        Lim::DEBUG and $self->{logger}->debug('Response JSON parse failed: ', $@);

essed weaken);

use HTTP::Status qw(:constants);
use HTTP::Request ();
use HTTP::Response ();
use JSON::XS ();

use Lim ();
use Lim::Util ();
use Lim::RPC::Callback ();

use base qw(Lim::RPC::Protocol

1 NAME

...

=head1 VERSION

See L<Lim> for version.

=cut

our $VERSION = $Lim::VERSION;
our $JSON = JSON::XS->new->utf8->convert_blessed;
our %REST_CRUD = (
    GET => 'READ',
    PUT => 'UPDATE',
 

ad1 SUBROUTINES/METHODS

=head2 Init

=cut

sub Init {
    if (Lim::Config->{rpc}->{json}->{pretty}) {
        $JSON->pretty(1);
    }
}

=head2 Destroy

=cut

sub Destroy {
}

=head2 name

=cut

sub 

m::RPC::Protocol::JSONRPC2;

use common::sense;

use Carp;
use Scalar::Util qw(blessed weaken);

use HTTP::Status qw(:constants);
use HTTP::Request ();
use HTTP::Response ();
use JSON::XS ();

use Lim

 $JSON = JSON::XS->new->utf8->convert_blessed;
our $ID = 1;
our $ID_OVERFLOW = 2^32;

=head1 SYNOPSIS

...

=head1 SUBROUTINES/METHODS

=head2 Init

=cut

sub Init {
    if (Lim::Config->{rpc}->{json}

->{pretty}) {
        $JSON->pretty(1);
    }
}

=head2 Destroy

=cut

sub Destroy {
}

=head2 name

=cut

sub name {
    'jsonrpc2';
}

=head2 serve

=cut

sub serve {
}

=head2 handle

=cut

sub han

$_[0];
}

=item $hash_ref = $error->TO_JSON

Returns a hash reference describing the error, this is to support passing
objects to L<JSON::XS>.

=cut

sub TO_JSON {
    {
        'Lim::Error' => {
    

use JSON;
use Net::HTTP::Spore;
use Net::HTTP::Spore::Middleware::DefaultParams;
use Net::HTTP::Spore::Middleware::Format::Text;


my $spec = {
    name => 'BrowserMob Proxy',
    formats => ['json'],

[
                'port'
            ],
            description => 'Create a new proxy. Returns a JSON object {"port": your_port} on success"'
        },
        delete_proxy => {
            method =

equired_params => [
                'port'
            ],
            description => 'returns the JSON/HAR content representing all the HTTP traffic passed through the proxy'
        },
        auth_b

 Crawl communities. CSV is too
ill-defined. XML is too heavyweight. I'd say the same for YAML and JSON.

=head1 FUNCTIONS

=head2 read_xlogfile FILENAME => ARRAY OF HASHREFS

Takes a file and parses i

er
controlled by a Brocade::BSC controller.

=cut

use strict;
use warnings;

use Data::Walk;
use JSON -convert_blessed_universally;

package Brocade::BSC::Node::NC::Vrouter::OvpnIf;

use parent qw(Cl

===
#
=item B<as_json>

  # Returns   : OpenVPN interface configuration as formatted JSON string.

=cut ===================================================================
sub as_json {
    my $self =

 shift;
    my $json = new JSON->canonical->allow_blessed->convert_blessed;
    return $json->pretty->encode($self);
}


# Subroutine ===========================================================
#     

er controlled
by a Brocade::BSC controller.

=cut

use strict;
use warnings;

use Data::Walk;
use JSON -convert_blessed_universally;

package Brocade::BSC::Node::NC::Vrouter::VPN;

use parent qw(Clone

m B<as_json>

  # Returns   : VPN as formatted JSON string.

=cut ===================================================================
sub as_json {
    my $self = shift;
    my $json = new JSON->canon

ical->allow_blessed->convert_blessed;
    return $json->pretty->encode($self);
}


# Subroutine ===========================================================
#             _strip_undef: remove all keys 

e_from(
                POST => '/',
                'Content-Type:' => 'text/json',
                'Content:' => '{ "json": "here" }',
              );

=item a L<Catalyst::Action> instance + option

rl client to control the Browsermob Proxy server
use strict;
use warnings;
use Moo;
use Carp;
use JSON;
use LWP::UserAgent;
use IO::Socket::INET;
use Browsermob::Proxy;


has path => (
    is => 'rw',

_addr . ':' . $self->server_port . '/proxy');
    if ($res->is_success) {
        my $list = from_json($res->decoded_content)->{proxyList};

        my @proxies = map {
            $_->{port};