view release on metacpan or  search on metacpan

src/catch.hpp  view on Meta::CPAN

#endif // __OBJC__

} // namespace Catch

//////////////////////////////////////////////////////
// Separate std-lib types stringification, so it can be selectively enabled
// This means that we do not bring in

#if defined(CATCH_CONFIG_ENABLE_ALL_STRINGMAKERS)
#  define CATCH_CONFIG_ENABLE_PAIR_STRINGMAKER
#  define CATCH_CONFIG_ENABLE_TUPLE_STRINGMAKER

src/catch.hpp  view on Meta::CPAN

    };
}
#endif // CATCH_CONFIG_ENABLE_TUPLE_STRINGMAKER

namespace Catch {
    struct not_this_one {}; // Tag type for detecting which begin/ end are being selected

    // Import begin/ end from std here so they are considered alongside the fallback (...) overloads in this namespace
    using std::begin;
    using std::end;

src/catch.hpp  view on Meta::CPAN

            assert( index < m_size );
            return m_generator->get( index );
        }
    };

    std::vector<size_t> randomiseIndices( size_t selectionSize, size_t sourceSize );

    template<typename T>
    class GeneratorRandomiser : public IGenerator<T> {
        Generator<T> m_baseGenerator;

src/catch.hpp  view on Meta::CPAN

        OcMethod( Class cls, SEL sel ) : m_cls( cls ), m_sel( sel ) {}

        virtual void invoke() const {
            id obj = [[m_cls alloc] init];

            performOptionalSelector( obj, @selector(setUp)  );
            performOptionalSelector( obj, m_sel );
            performOptionalSelector( obj, @selector(tearDown)  );

            arcSafeRelease( obj );
        }
    private:
        virtual ~OcMethod() {}

src/catch.hpp  view on Meta::CPAN

            Class cls = classes[c];
            {
                u_int count;
                Method* methods = class_copyMethodList( cls, &count );
                for( u_int m = 0; m < count ; m++ ) {
                    SEL selector = method_getName(methods[m]);
                    std::string methodName = sel_getName(selector);
                    if( startsWith( methodName, "Catch_TestCase_" ) ) {
                        std::string testCaseName = methodName.substr( 15 );
                        std::string name = Detail::getAnnotation( cls, "Name", testCaseName );
                        std::string desc = Detail::getAnnotation( cls, "Description", testCaseName );
                        const char* className = class_getName( cls );

                        getMutableRegistryHub().registerTest( makeTestCase( new OcMethod( cls, selector ), className, NameAndTags( name.c_str(), desc.c_str() ), SourceLineInfo("",0) ) );
                        noTestMethods++;
                    }
                }
                free(methods);
            }

src/catch.hpp  view on Meta::CPAN

namespace Generators {

    GeneratorBase::~GeneratorBase() {}

    std::vector<size_t> randomiseIndices( size_t selectionSize, size_t sourceSize ) {

        assert( selectionSize <= sourceSize );
        std::vector<size_t> indices;
        indices.reserve( selectionSize );
        std::uniform_int_distribution<size_t> uid( 0, sourceSize-1 );

        std::set<size_t> seen;
        // !TBD: improve this algorithm
        while( indices.size() < selectionSize ) {
            auto index = uid( rng() );
            if( seen.insert( index ).second )
                indices.push_back( index );
        }
        return indices;

 view release on metacpan or  search on metacpan

lib/Alien/curlimpersonate.pm  view on Meta::CPAN

reproduces a real browser's TLS and HTTP/2 fingerprint -- JA3/JA4 and the
HTTP/2 SETTINGS "Akamai" fingerprint -- rather than the one libcurl would
otherwise present. See L<Curl::Impersonate> for a Perl client built on it.

This is a source-only Alien: there is no system package of
libcurl-impersonate to find, so the probe always selects a C<share> install
and the library is compiled at install time. See L</"SYSTEM REQUIREMENTS">,
because that build is neither short nor dependency-free.

The pinned version is B<v2.2.2>, built from
L<https://github.com/lexiforest/curl-impersonate> itself. It is an exact tag

 view release on metacpan or  search on metacpan

patch/flex-2.6.4.diff  view on Meta::CPAN

-  test -z "$as_dir" && as_dir=.
-    for ac_prog in sed gsed; do
-    for ac_exec_ext in '' $ac_executable_extensions; do
-      ac_path_SED="$as_dir/$ac_prog$ac_exec_ext"
-      as_fn_executable_p "$ac_path_SED" || continue
-# Check for GNU ac_path_SED and select it if it is found.
-  # Check for GNU $ac_path_SED
-case `"$ac_path_SED" --version 2>&1` in
-*GNU*)
-  ac_cv_path_SED="$ac_path_SED" ac_path_SED_found=:;;
-*)

patch/flex-2.6.4.diff  view on Meta::CPAN

-  test -z "$as_dir" && as_dir=.
-    for ac_prog in fgrep; do
-    for ac_exec_ext in '' $ac_executable_extensions; do
-      ac_path_FGREP="$as_dir/$ac_prog$ac_exec_ext"
-      as_fn_executable_p "$ac_path_FGREP" || continue
-# Check for GNU ac_path_FGREP and select it if it is found.
-  # Check for GNU $ac_path_FGREP
-case `"$ac_path_FGREP" --version 2>&1` in
-*GNU*)
-  ac_cv_path_FGREP="$ac_path_FGREP" ac_path_FGREP_found=:;;
-*)

patch/flex-2.6.4.diff  view on Meta::CPAN

+  test -z "$as_dir" && as_dir=.
+    for ac_prog in sed gsed; do
+    for ac_exec_ext in '' $ac_executable_extensions; do
+      ac_path_SED="$as_dir/$ac_prog$ac_exec_ext"
+      as_fn_executable_p "$ac_path_SED" || continue
+# Check for GNU ac_path_SED and select it if it is found.
+  # Check for GNU $ac_path_SED
+case `"$ac_path_SED" --version 2>&1` in
+*GNU*)
+  ac_cv_path_SED="$ac_path_SED" ac_path_SED_found=:;;
+*)

patch/flex-2.6.4.diff  view on Meta::CPAN

+  test -z "$as_dir" && as_dir=.
+    for ac_prog in fgrep; do
+    for ac_exec_ext in '' $ac_executable_extensions; do
+      ac_path_FGREP="$as_dir/$ac_prog$ac_exec_ext"
+      as_fn_executable_p "$ac_path_FGREP" || continue
+# Check for GNU ac_path_FGREP and select it if it is found.
+  # Check for GNU $ac_path_FGREP
+case `"$ac_path_FGREP" --version 2>&1` in
+*GNU*)
+  ac_cv_path_FGREP="$ac_path_FGREP" ac_path_FGREP_found=:;;
+*)

 view release on metacpan or  search on metacpan

.claude/skills/alien-gettext-core/SKILL.md  view on Meta::CPAN

## The pattern picks "newest on the mirror"

`Dist::Zilla::Plugin::Alien` defaults the download pattern to
`^gettext-([\d\.]+)\.tar\.gz$` (prefix = module name minus `Alien-`, i.e.
`gettext-`; version `([\d\.]+)`; suffix `\.tar\.gz`). It selects the
highest-versioned match in `alien_repo`. Nothing pins a version — a new GNU
release is picked up automatically on the next share install. Set
`alien_pattern*` / `alien_exact_filename` in `dist.ini` if that ever needs
constraining.

 view release on metacpan or  search on metacpan

alienfile  view on Meta::CPAN

    memset(&opts, 0, sizeof opts);
    opts.size = sizeof opts;
    opts.extra.size = sizeof opts.extra;
    opts.extra.screen.size = sizeof opts.extra.screen;
    opts.emit = GHOSTTY_FORMATTER_FORMAT_PLAIN;
    opts.selection = &sel;
    if (ghostty_formatter_terminal_new(NULL, &fmt, term, opts) != GHOSTTY_SUCCESS)
        return 1;
    if (ghostty_formatter_format_alloc(fmt, NULL, &buf, &len) != GHOSTTY_SUCCESS)
        return 1;
    ghostty_free(NULL, buf, len);

 view release on metacpan or  search on metacpan

Build.PL  view on Meta::CPAN

        'make install'
    ],
    alien_bin_requires => { %nonwin32 },
    meta_merge => {
        resources => {
            repository => "https://github.com/selectiveintellect/p5-alien-gputils",
            bugtracker => "https://github.com/selectiveintellect/p5-alien-gputils/issues",
        },
    },
);

$build->create_build_script;

 view release on metacpan or  search on metacpan

bundled/include/histo/histo.h  view on Meta::CPAN

/**
 * @brief Binning estimation heuristic rules.
 */
typedef enum histo_bin_rule {
    HISTO_BIN_RULE_AUTO    = 0,  /**< Automatic selection: Freedman-Diaconis with fallback to Scott [Default] */
    HISTO_BIN_RULE_FD      = 1,  /**< Freedman-Diaconis: h = 2 * IQR * n^(-1/3) */
    HISTO_BIN_RULE_SCOTT   = 2,  /**< Scott's normal reference: h = 3.49 * std * n^(-1/3) */
    HISTO_BIN_RULE_STURGES = 3,  /**< Sturges' rule: k = ceil(log2(n) + 1) */
    HISTO_BIN_RULE_DOANE   = 4,  /**< Doane's rule: Sturges adjusted for skewness */
    HISTO_BIN_RULE_KNUTH   = 5   /**< Knuth's Bayesian optimal binning rule */

 view release on metacpan or  search on metacpan

libsecp256k1/build/CMakeFiles/3.21.4/CompilerIdC/CMakeCCompilerId.c  view on Meta::CPAN

#ifdef __cplusplus
# error "A C++ compiler has been selected for C."
#endif

#if defined(__18CXX)
# define ID_VOID_MAIN
#endif

 view release on metacpan or  search on metacpan

.claude/skills/kanban-issues-karr-cli/SKILL.md  view on Meta::CPAN

settles, printing the reason it lifted. A far card that does not exist settles
nothing. A board this machine cannot place is reported, not fatal.

Like `depends_on`, a cross-board link blocks nothing by itself: `pick` hands the
card over and says what it waits on. The `blocked` flag is what keeps the card
out of `pick` and out of karr-foundation's selection -- the link is the fact,
`blocked` is the decision.

### Config

```bash

 view release on metacpan or  search on metacpan

.tidyallrc  view on Meta::CPAN

; https://perladvent.org/2020/2020-12-01.html

ignore = **/*.bak **/_*.pm blib/**/* builder/_alien/**/* extract/**/* dyncall/**/*

[PerlTidy]
select = **/*.{pl,pm,t}
select = cpanfile
select = alienfile
argv = -anl -baao --check-syntax --closing-side-comments-balanced -nce -dnl --delete-old-whitespace --delete-semicolons -fs -nhsc -ibc -bar -nbl -ohbr -opr -osbr -nsbl -nasbl -otr -olc --perl-best-practices --nostandard-output -sbc -nssc --break-at-o...
;argv = -noll -it=2 -l=100 -i=4 -ci=4 -se -b -bar -boc -vt=0 -vtc=0 -cti=0 -pt=1 -bt=1 -sbt=1 -bbt=1 -nolq -npro -nsfs --opening-hash-brace-right --no-outdent-long-comments -wbb="% + - * / x != == >= <= =~ !~ < > | & >= < = **= += *= &= <<= &&= -= /=...

;[PerlCritic]
;select = lib/**/*.pm
;ignore = lib/UtterHack.pm lib/OneTime/*.pm
;argv = -severity 3

[PodTidy]
select = lib/**/*.{pm,pod}

[PodChecker]
select = **/*.{pl,pm,pod}

;[Test::Vars]
;select = **/*.{pl,pl.in,pm,t}

;[PodSpell]
;select = **/*.{pl,pl.in,pm,pod}

[ClangFormat]
select = **/*.{cpp,h,c,xs,xsh}

 view release on metacpan or  search on metacpan

t/use.t  view on Meta::CPAN

my($wtr, $rdr, $err);
use Symbol 'gensym'; $err = gensym;
my $pid = open3($wtr, $rdr, $err,
	$p->pdf2json_path, "-help" );
# WARN: this could block --- I should use select() or IPC::Run3, but this may work for now
my $result = join "", <$err>;
waitpid( $pid, 0 );

like($result, qr/pdf2json version/, 'can run pdf2json');

 view release on metacpan or  search on metacpan

MANIFEST  view on Meta::CPAN

libuv/test/test-loop-handles.c
libuv/test/test-loop-stop.c
libuv/test/test-loop-time.c
libuv/test/test-multiple-listen.c
libuv/test/test-mutexes.c
libuv/test/test-osx-select.c
libuv/test/test-pass-always.c
libuv/test/test-ping-pong.c
libuv/test/test-pipe-bind-error.c
libuv/test/test-pipe-close-stdout-read-stdin.c
libuv/test/test-pipe-connect-error.c

 view release on metacpan or  search on metacpan

inc/inc_IPC-Cmd/IPC/Cmd.pm  view on Meta::CPAN

                );

    ### use OUR stdin, not $kidin. Somehow,
    ### we never get the input.. so jump through
    ### some hoops to do it :(
    my $selector = IO::Select->new(
                        (IS_WIN32 ? \*STDERR : $kiderror), 
                        \*STDIN,   
                        (IS_WIN32 ? \*STDOUT : $kidout)     
                    );              

inc/inc_IPC-Cmd/IPC/Cmd.pm  view on Meta::CPAN

    $kidout->autoflush(1)   if UNIVERSAL::can($kidout,   'autoflush');
    $kiderror->autoflush(1) if UNIVERSAL::can($kiderror, 'autoflush');

    ### add an epxlicit break statement
    ### code courtesy of theorbtwo from #london.pm
    OUTER: while ( my @ready = $selector->can_read ) {

        for my $h ( @ready ) {
            my $buf;
            
            ### $len is the amount of bytes read

 view release on metacpan or  search on metacpan

lib/Align/Sequence.pm  view on Meta::CPAN

  my $Ycurrent = -1;
  my $Xtemp;
  my $Ytemp;
  
  my @L; # LCS
  my $R = 0;  # records the position of last selected symbol
  my $i;
  
  my $Pi;
  my $Pi1;
  

 view release on metacpan or  search on metacpan

ppport.h  view on Meta::CPAN

ck_retarget|||
ck_return|||
ck_rfun|||
ck_rvconst|||
ck_sassign|||
ck_select|||
ck_shift|||
ck_sort|||
ck_spair|||
ck_split|||
ck_subr|||

 view release on metacpan or  search on metacpan

lib/AlignDB/SQL.pm  view on Meta::CPAN

use YAML qw(Dump Load DumpFile LoadFile);
with Storage( 'format' => 'YAML' );

our $VERSION = '1.0.2';

has 'select'             => ( is => 'rw', isa => 'ArrayRef', default => sub { [] } );
has 'select_map'         => ( is => 'rw', isa => 'HashRef',  default => sub { {} } );
has 'select_map_reverse' => ( is => 'rw', isa => 'HashRef',  default => sub { {} } );
has 'from'               => ( is => 'rw', isa => 'ArrayRef', default => sub { [] } );
has 'joins'              => ( is => 'rw', isa => 'ArrayRef', default => sub { [] } );
has 'where'              => ( is => 'rw', isa => 'ArrayRef', default => sub { [] } );
has 'bind'               => ( is => 'rw', isa => 'ArrayRef', default => sub { [] } );
has 'limit'              => ( is => 'rw', isa => 'Int' );

lib/AlignDB/SQL.pm  view on Meta::CPAN

has 'where_values'       => ( is => 'rw', isa => 'HashRef',  default => sub { {} } );
has '_sql'    => ( is => 'rw', isa => 'Str',     default => '' );
has 'indent'  => ( is => 'rw', isa => 'Str',     default => ' ' x 2 );
has 'replace' => ( is => 'rw', isa => 'HashRef', default => sub { {} } );

sub add_select {
    my $self = shift;
    my ( $term, $col ) = @_;
    $col ||= $term;
    push @{ $self->select }, $term;
    $self->select_map->{$term}        = $col;
    $self->select_map_reverse->{$col} = $term;
}

sub add_join {
    my $self = shift;
    my ( $table, $joins ) = @_;

lib/AlignDB/SQL.pm  view on Meta::CPAN

sub as_header {
    my $self = shift;

    my @terms;
    if ( @{ $self->select } ) {
        my %select_map = %{ $self->select_map };
        for my $term ( @{ $self->select } ) {
            if ( exists $select_map{$term} ) {
                my $alias = $select_map{$term};
                push @terms, $alias;
            }
            else {
                push @terms, $term;
            }

lib/AlignDB/SQL.pm  view on Meta::CPAN

    my $self = shift;

    my $indent = $self->indent;
    my $sql    = '';

    if ( @{ $self->select } ) {
        my %select_map = %{ $self->select_map };
        my @terms;
        for my $term ( @{ $self->select } ) {
            if ( exists $select_map{$term} ) {
                my $alias = $select_map{$term};

                # add_select( 'f.foo'    => 'foo' ) ===> f.foo
                # add_select( 'COUNT(*)' => 'count' ) ===> COUNT(*) count
                if ( $alias and $term =~ /(?:^|\.)\Q$alias\E$/ ) {
                    push @terms, $term;
                }
                else {
                    push @terms, "$term $alias";

lib/AlignDB/SQL.pm  view on Meta::CPAN

sub add_having {
    my $self = shift;
    my ( $col, $val ) = @_;

    if ( my $orig = $self->select_map_reverse->{$col} ) {
        $col = $orig;
    }

    my ( $term, $bind ) = $self->_mk_term( $col, $val );
    push @{ $self->{having} }, "($term)";

lib/AlignDB/SQL.pm  view on Meta::CPAN

AlignDB::SQL - An SQL statement generator.

=head1 SYNOPSIS

    my $sql = AlignDB::SQL->new();
    $sql->select([ 'id', 'name', 'bucket_id', 'note_id' ]);
    $sql->from([ 'foo' ]);
    $sql->add_where('name',      'fred');
    $sql->add_where('bucket_id', { op => '!=', value => 47 });
    $sql->add_where('note_id',   \'IS NULL');
    $sql->limit(1);

    my $sth = $dbh->prepare($sql->as_sql);
    $sth->execute(@{ $sql->{bind} });
    my @values = $sth->selectrow_array();

    my $obj = SomeObject->new();
    $obj->set_columns(...);

=head1 DESCRIPTION

 view release on metacpan or  search on metacpan

inc/Capture/Tiny.pm  view on Meta::CPAN

  my ($which, $stash) = @_; # $which is "stdout" or "stderr"
  # setup pipes
  $stash->{$_}{$which} = IO::Handle->new for qw/tee reader/;
  pipe $stash->{reader}{$which}, $stash->{tee}{$which};
  # _debug( "# pipe for $which\: " .  _name($stash->{tee}{$which}) . " " . fileno( $stash->{tee}{$which} ) . " => " . _name($stash->{reader}{$which}) . " " . fileno( $stash->{reader}{$which}) . "\n" );
  select((select($stash->{tee}{$which}), $|=1)[0]); # autoflush
  # setup desired redirection for parent and child
  $stash->{new}{$which} = $stash->{tee}{$which};
  $stash->{child}{$which} = {
    stdin   => $stash->{reader}{$which},
    stdout  => $stash->{old}{$which},

 view release on metacpan or  search on metacpan

lib/CWB.pm  view on Meta::CPAN

B<list_attributes()> returns the names of all declared attributes. The
B<attribute()> method returns the type of the specified attribute, or an
undefined value if the attribute is not declared. I<$type> is one of
C<'p'> (B<positional>), C<'s'> (B<structural>), or C<'a'> (B<alignment>). 
Passing one of these type codes to B<list_attributes()> will return
attributes of the selected type only. 

=cut

sub list_attributes ( $;$ ) {
  my ($self, $type) = @_;

 view release on metacpan or  search on metacpan

ppport.h  view on Meta::CPAN

KEY_s|5.003007||Viu
KEY_say|5.009003||Viu
KEY_scalar|5.003007||Viu
KEY_seek|5.003007||Viu
KEY_seekdir|5.003007||Viu
KEY_select|5.003007||Viu
KEY_semctl|5.003007||Viu
KEY_semget|5.003007||Viu
KEY_semop|5.003007||Viu
KEY_send|5.003007||Viu
KEY_setgrent|5.003007||Viu

ppport.h  view on Meta::CPAN

PerlSock_listen|5.005000||Viu
PerlSock_ntohl|5.005000||Viu
PerlSock_ntohs|5.005000||Viu
PerlSock_recv|5.005000||Viu
PerlSock_recvfrom|5.005000||Viu
PerlSock_select|5.005000||Viu
PerlSock_send|5.005000||Viu
PerlSock_sendto|5.005000||Viu
PerlSock_sethostent|5.005000||Viu
PerlSock_setnetent|5.005000||Viu
PerlSock_setprotoent|5.005000||Viu

ppport.h  view on Meta::CPAN

seedDrand01|5.006000|5.006000|
SEEK_CUR|5.003007||Viu
seekdir|5.005000||Viu
SEEK_END|5.003007||Viu
SEEK_SET|5.003007||Viu
select|5.005000||Viu
Select_fd_set_t|5.003007|5.003007|Vn
SELECT_MIN_BITS|5.005003|5.005003|Vn
Semctl|5.004005||Viu
semun|5.006000||Viu
send|5.005000||Viu

 view release on metacpan or  search on metacpan

lib/Crypt/RSA/Key.pm  view on Meta::CPAN

        # Switch from Maurer prime to nbit prime, then add some more primality
        # testing.  This is faster and gives us a wider set of possible primes.

        # We really ought to consider the distribution.  See:
        # https://crocs.fi.muni.cz/_media/public/papers/usenixsec16_1mrsakeys_trfimu_201603.pdf
        # for comments on p/q selection.

        while (1) {
          my $p = random_nbit_prime($size);
          my $q = random_nbit_prime($size);
          $p = Math::BigInt->new("$p") unless ref($p) eq 'Math::BigInt';

 view release on metacpan or  search on metacpan

Changes  view on Meta::CPAN

0.003       2014-12-31 00:39:04-0600
    - add a role for Rlike data frames
          * support for methods: head(), tail(), subset()
    - use MooX::Traits to support loading roles easily
    - fix: select_rows() with no arguments should return an empty Data::Frame
    - bump PDL version to use its `unpdl()` method
    - Column::Helper now uses AUTOLOAD to make accessing columns easier in `subset()`

0.002       2014-12-25 03:34:04-0600
    - fix stringifiable length test

 view release on metacpan or  search on metacpan

inc/TestML/Runtime.pm  view on Meta::CPAN

    }
}

sub run_statement {
    my ($self, $statement) = @_;
    my $blocks = $self->select_blocks($statement->points || []);
    for my $block (@$blocks) {
        $self->function->setvar('Block', $block) if $block != 1;
        my $result = $self->run_expression($statement->expr);
        if (my $assert = $statement->assert) {
            $self->run_assertion($result, $assert);

inc/TestML/Runtime.pm  view on Meta::CPAN

    }
    $value =~ s/^\\//gm;
    return TestML::Str->new(value => $value);
}

sub select_blocks {
    my ($self, $wanted) = @_;
    return [1] unless @$wanted;
    my $selected = [];

    OUTER: for my $block (@{$self->function->data}) {
        my %points = %{$block->points};
        next if exists $points{SKIP};
        if (exists $points{ONLY}) {
            for my $point (@$wanted) {
                return [] unless exists $points{$point};
            }
            $selected = [$block];
            last;
        }
        for my $point (@$wanted) {
            next OUTER unless exists $points{$point};
        }
        push @$selected, $block;
        last if exists $points{LAST};
    }
    return $selected;
}

sub compile_testml {
    my ($self) = @_;

 view release on metacpan or  search on metacpan

inc/Capture/Tiny.pm  view on Meta::CPAN

  my ($which, $stash) = @_; # $which is "stdout" or "stderr"
  # setup pipes
  $stash->{$_}{$which} = IO::Handle->new for qw/tee reader/;
  pipe $stash->{reader}{$which}, $stash->{tee}{$which};
  # _debug( "# pipe for $which\: " .  _name($stash->{tee}{$which}) . " " . fileno( $stash->{tee}{$which} ) . " => " . _name($stash->{reader}{$which}) . " " . fileno( $stash->{reader}{$which}) . "\n" );
  select((select($stash->{tee}{$which}), $|=1)[0]); # autoflush
  # setup desired redirection for parent and child
  $stash->{new}{$which} = $stash->{tee}{$which};
  $stash->{child}{$which} = {
    stdin   => $stash->{reader}{$which},
    stdout  => $stash->{old}{$which},

 view release on metacpan or  search on metacpan

lib/NewRelic/Agent/FFI/Procedural.pm  view on Meta::CPAN

 my $seg = newrelic_segment_datastore_begin $tx, $parent_seg, $table, $operation, $sql, $sql_trace_rollup_name;
 my $seg = newrelic_segment_datastore_begin $tx, $parent_seg, $table, $operation, $sql, $sql_trace_rollup_name, $sql_obfuscator;

Begins a new datastore segment.  C<$parent_seg> is a parent segment id (C<undef> no parent).  C<$operation> should be
one of C<select>, C<insert>, C<update> or C<delete>.

If you want to provide your own obfuscator, you need to pass in the address of a C function.  To do that from Perl you can
create a closure with L<FFI::Platypus>, like so:

 use 5.010;

 view release on metacpan or  search on metacpan

lib/Sex.pm  view on Meta::CPAN

    }

    while( my($chromo, $rna) = each %zygote ) {
        $call_sym_table->{$chromo} = $rna->[rand @$rna];
        print $Grunts[rand @Grunts], "\n";
        #select(undef, undef, undef, 0.45);
    }

    # push @{$caller.'::ISA'}, @modules;

    print "\n";

 view release on metacpan or  search on metacpan

t/Test/Builder.pm  view on Meta::CPAN

}


sub _autoflush {
    my($fh) = shift;
    my $old_fh = select $fh;
    $| = 1;
    select $old_fh;
}


sub _dup_stdhandles {
    my $self = shift;

 view release on metacpan or  search on metacpan

lib/Tickit/Widget/CheckButton.pm  view on Meta::CPAN

 Tickit->new( root => $vbox )->run;

=head1 DESCRIPTION

This class provides a widget which allows a true/false selection. It displays
a clickable indication of status and a caption. Clicking on the status or
caption inverts the status of the widget.

This widget is part of an experiment in evolving the design of the
L<Tickit::Style> widget integration code, and such is subject to change of

 view release on metacpan or  search on metacpan

ppport.h  view on Meta::CPAN

ck_retarget|||
ck_return|||
ck_rfun|||
ck_rvconst|||
ck_sassign|||
ck_select|||
ck_shift|||
ck_sort|||
ck_spair|||
ck_split|||
ck_subr|||