Result:
found 771 distributions and 1902 files matching your query !
( run in 1.824 )
Plack-Middleware-ServerName
view release on metacpan or search on metacpan
inc/Module/Install/Repository.pm view on Meta::CPAN
if ($query_repo =~ m!Default Remote: (http://.+)!) {
return $1;
}
}
open my $handle, '<', '_darcs/prefs/repos' or return;
while (<$handle>) {
chomp;
return $_ if m!^http://!;
}
} elsif (-e ".hg") {
Plack-Middleware-Throttle
view release on metacpan or search on metacpan
inc/Module/Install/Repository.pm view on Meta::CPAN
if ($query_repo =~ m!Default Remote: (http://.+)!) {
return $1;
}
}
open my $handle, '<', '_darcs/prefs/repos' or return;
while (<$handle>) {
chomp;
return $_ if m!^http://!;
}
} elsif (-e ".hg") {
Plack-Server-AnyEvent
view release on metacpan or search on metacpan
inc/Module/Install/Repository.pm view on Meta::CPAN
if ($query_repo =~ m!Default Remote: (http://.+)!) {
return $1;
}
}
open my $handle, '<', '_darcs/prefs/repos' or return;
while (<$handle>) {
chomp;
return $_ if m!^http://!;
}
} elsif (-e ".hg") {
Plack-Server-Coro
view release on metacpan or search on metacpan
inc/Module/Install/Repository.pm view on Meta::CPAN
if ($query_repo =~ m!Default Remote: (http://.+)!) {
return $1;
}
}
open my $handle, '<', '_darcs/prefs/repos' or return;
while (<$handle>) {
chomp;
return $_ if m!^http://!;
}
} elsif (-e ".hg") {
PlotCalendar
view release on metacpan or search on metacpan
PlotCalendar/Month.pm view on Meta::CPAN
$string .= "</TR>\n";
# If there are comments, we'll need to deal with them
my $comments = 0;
my (@prefs, @comments, @comcol, @comstyle, @comsize);
if ($self->{COMMFLAG}) {
@prefs = @{$self->{COMMENTS}[0]};
@comments = @{$self->{COMMENTS}[1]};
@comcol = @{$self->{COMMENTS}[2]};
@comstyle = @{$self->{COMMENTS}[3]};
@comsize = @{$self->{COMMENTS}[4]};
$comments = @prefs;
}
# add in all the days
my $numdays = Days_in_Month($year, $self->{MONTH}); # num days in month
PlotCalendar/Month.pm view on Meta::CPAN
$day -> htmlref($self->{HTMLREF}[$curday]);
}
$string .= $day -> gethtml; # ---- add in cell
}
else {
if ($comments && $curday == 0 && grep(/before/,@prefs)) {
# I am in the before zone and can use it
my $k;
for ($k=0;$k<@prefs;$k++) {
last if $prefs[$k] eq 'before' ;
}
$string .= &makecomm($self,$comments[$k],$comcol[$k],$comstyle[$k],$comsize[$k]);
splice(@prefs,$k,1);
splice(@comments,$k,1);
splice(@comcol,$k,1);
splice(@comstyle,$k,1);
splice(@comsize,$k,1);
$comments--;
}
elsif ($comments && $curday > 0 ) {
# I am in the after zone and can use it
$string .= &makecomm($self,$comments[0],$comcol[0],$comstyle[0],$comsize[0]);
shift @prefs;
shift @comments;
shift @comcol;
shift @comstyle;
shift @comsize;
$comments--;
PlotCalendar/Month.pm view on Meta::CPAN
$string .= "<TR>\n";
for (my $col=0;$col<7;$col++) {
if ($comments) {
# I am in the after zone and can use it
$string .= &makecomm($self,$comments[0],$comcol[0],$comstyle[0],$comsize[0]);
shift @prefs;
shift @comments;
shift @comcol;
shift @comstyle;
shift @comsize;
$comments--;
PlotCalendar/Month.pm view on Meta::CPAN
$month -> bgcolor(@bgcolor); # Background color per day
$month -> styles('b','bi','ui',); # Global text styles
# Comments
my @prefs = ('before','after','after');
my @comments = (['Comment one'],["Comment two","and so on"],['Comment three']);
my @comcol = qw(b g b);
my @comstyle = qw(n b bi);
my @comsize = qw(8 10 14);
------------------------- Comments get stuck into an otherwise empty cell
$month->comments(\@prefs,\@comments,\@comcol,\@comstyle,\@comsize);
------------------------- Wrap a hotlink around the whole day, for each day
$month -> htmlref(@url);
------------------------- set the names for every day
Pod-Generated
view release on metacpan or search on metacpan
inc/Module/Install/Repository.pm view on Meta::CPAN
if ($query_repo =~ m!Default Remote: (http://.+)!) {
return $1;
}
}
open my $handle, '<', '_darcs/prefs/repos' or return;
while (<$handle>) {
chomp;
return $_ if m!^http://!;
}
} elsif (-e ".hg") {
Pod-HTMLEmbed
view release on metacpan or search on metacpan
inc/Module/Install/Repository.pm view on Meta::CPAN
if ($query_repo =~ m!Default Remote: (http://.+)!) {
return $1;
}
}
open my $handle, '<', '_darcs/prefs/repos' or return;
while (<$handle>) {
chomp;
return $_ if m!^http://!;
}
} elsif (-e ".hg") {
Pongo
view release on metacpan or search on metacpan
lib/Pongo/Client.xs view on Meta::CPAN
mongoc_transaction_state_t T_PTROBJ
mongoc_client_session_with_transaction_cb_t T_PTROBJ
const mongoc_session_opt_t * T_PTROBJ
mongoc_server_description_t ** T_PTROBJ
uint32_t * T_PTROBJ
const mongoc_read_prefs_t * T_PTROBJ
mongoc_query_flags_t T_PTROBJ
const mongoc_client_t * T_PTROBJ
char ** T_PTROBJ
mongoc_gridfs_t * T_PTROBJ
mongoc_server_description_t * T_PTROBJ
mongoc_read_prefs_t * T_PTROBJ
const mongoc_read_concern_t * T_PTROBJ
mongoc_session_opt_t * T_PTROBJ
mongoc_stream_initiator_t T_PTROBJ
mongoc_index_model_t * T_PTROBJ
const mongoc_index_opt_t * T_PTROBJ
lib/Pongo/Client.xs view on Meta::CPAN
RETVAL = mongoc_client_bulkwrite_new(self);
OUTPUT:
RETVAL
mongoc_cursor_t *
client_command(client, db_name, flags, skip, limit, batch_size, query, fields, read_prefs)
mongoc_client_t *client;
const char *db_name;
mongoc_query_flags_t flags;
uint32_t skip;
uint32_t limit;
uint32_t batch_size;
const bson_t *query;
const bson_t *fields;
const mongoc_read_prefs_t *read_prefs;
CODE:
RETVAL = mongoc_client_command(client, db_name , flags, skip, limit, batch_size, query, fields, read_prefs);
OUTPUT:
RETVAL
bool
client_command_simple(client, db_name, command, read_prefs, reply, error)
mongoc_client_t *client;
const char *db_name;
const bson_t *command;
const mongoc_read_prefs_t *read_prefs;
bson_t *reply;
bson_error_t *error;
CODE:
RETVAL = mongoc_client_command_simple(client, db_name, command, read_prefs, reply, error);
OUTPUT:
RETVAL
bool
client_command_simple_with_server_id(client, db_name, command, read_prefs, server_id, reply, error)
mongoc_client_t * client;
const char *db_name;
const bson_t *command;
const mongoc_read_prefs_t *read_prefs;
uint32_t server_id;
bson_t *reply;
bson_error_t *error;
CODE:
RETVAL = mongoc_client_command_simple_with_server_id(client, db_name, command, read_prefs, server_id, reply, error);
OUTPUT:
RETVAL
bool
client_command_with_opts(client, db_name, command, read_prefs, opts, reply, error)
mongoc_client_t *client;
const char *db_name;
const bson_t *command;
const mongoc_read_prefs_t *read_prefs;
const bson_t *opts;
bson_t *reply;
bson_error_t *error;
CODE:
RETVAL = mongoc_client_command_with_opts(client, db_name, command, read_prefs, opts, reply, error);
OUTPUT:
RETVAL
void
client_destroy(client)
lib/Pongo/Client.xs view on Meta::CPAN
CODE:
RETVAL = mongoc_client_get_read_concern(client);
OUTPUT:
RETVAL
const mongoc_read_prefs_t *
client_get_read_prefs(client)
const mongoc_client_t *client;
CODE:
RETVAL = mongoc_client_get_read_prefs(client);
OUTPUT:
RETVAL
mongoc_server_description_t *
client_get_server_description(client, server_id)
lib/Pongo/Client.xs view on Meta::CPAN
RETVAL = mongoc_client_get_server_descriptions(client, n);
OUTPUT:
RETVAL
bool
client_get_server_status(client, read_prefs, reply, error)
mongoc_client_t *client;
mongoc_read_prefs_t *read_prefs;
bson_t *reply;
bson_error_t *error;
CODE:
RETVAL = mongoc_client_get_server_status(client, read_prefs, reply, error);
OUTPUT:
RETVAL
const mongoc_uri_t *
client_get_uri(client)
lib/Pongo/Client.xs view on Meta::CPAN
RETVAL = mongoc_client_new_from_uri_with_error(uri, error);
OUTPUT:
RETVAL
bool
client_read_command_with_opts(client, db_name, command, read_prefs, opts, reply, error)
mongoc_client_t *client;
const char *db_name;
const bson_t *command;
const mongoc_read_prefs_t *read_prefs;
const bson_t *opts;
bson_t *reply;
bson_error_t *error;
CODE:
RETVAL = mongoc_client_read_command_with_opts(client, db_name, command, read_prefs, opts, reply, error);
OUTPUT:
RETVAL
bool
client_read_write_command_with_opts(client, db_name, command, read_prefs, opts, reply, error)
mongoc_client_t *client;
const char *db_name;
const bson_t *command;
const mongoc_read_prefs_t *read_prefs;
const bson_t *opts;
bson_t *reply;
bson_error_t *error;
CODE:
RETVAL = mongoc_client_read_write_command_with_opts(client, db_name, command, read_prefs, opts, reply, error);
OUTPUT:
RETVAL
void
client_reset(client)
mongoc_client_t *client;
CODE:
mongoc_client_reset(client);
mongoc_server_description_t *
client_select_server(client, for_writes, prefs, error)
mongoc_client_t *client;
bool for_writes;
const mongoc_read_prefs_t *prefs;
bson_error_t *error;
CODE:
RETVAL = mongoc_client_select_server(client, for_writes, prefs, error);
OUTPUT:
RETVAL
bool
client_set_apm_callbacks(client, callbacks, context)
lib/Pongo/Client.xs view on Meta::CPAN
const mongoc_read_concern_t *read_concern;
CODE:
mongoc_client_set_read_concern(client, read_concern);
void
client_set_read_prefs(client, read_prefs)
mongoc_client_t *client;
const mongoc_read_prefs_t *read_prefs;
CODE:
mongoc_client_set_read_prefs(client, read_prefs);
bool
client_set_server_api(client, api, error)
mongoc_client_t *client;
const mongoc_server_api_t *api;
lib/Pongo/Client.xs view on Meta::CPAN
RETVAL = mongoc_handshake_data_append(driver_name, driver_version, platform);
OUTPUT:
RETVAL
mongoc_cursor_t *
collection_aggregate(collection, flags, pipeline, opts, read_prefs)
mongoc_collection_t *collection;
int flags;
SV *pipeline;
SV *opts;
SV *read_prefs;
CODE:
mongoc_query_flags_t flag_value = (mongoc_query_flags_t) flags;
const bson_t *bson_pipeline = (const bson_t *) SvIV(SvRV(pipeline));
const bson_t *bson_opts = (const bson_t *) SvIV(SvRV(opts));
const mongoc_read_prefs_t *read_prefs_value = NULL;
if (SvOK(read_prefs)) {
read_prefs_value = (const mongoc_read_prefs_t*) SvIV(SvRV(read_prefs));
}
RETVAL = mongoc_collection_aggregate(collection, flag_value, bson_pipeline, bson_opts, read_prefs_value);
OUTPUT:
RETVAL
mongoc_cursor_t *
collection_command(collection, flags, skip, limit, batch_size, command, fields, read_prefs)
mongoc_collection_t *collection;
mongoc_query_flags_t flags;
uint32_t skip;
uint32_t limit;
uint32_t batch_size;
const bson_t *command;
const bson_t *fields;
const mongoc_read_prefs_t *read_prefs;
CODE:
RETVAL = mongoc_collection_command(collection, flags, skip, limit, batch_size, command, fields, read_prefs);
OUTPUT:
RETVAL
bool
collection_command_simple(collection, command, read_prefs, reply, error)
mongoc_collection_t *collection;
const bson_t *command;
const mongoc_read_prefs_t *read_prefs;
bson_t *reply;
bson_error_t *error;
CODE:
RETVAL = mongoc_collection_command_simple(collection, command, read_prefs, reply, error);
OUTPUT:
RETVAL
bool
collection_command_with_opts(collection, command, read_prefs,opts, reply, error)
mongoc_collection_t *collection;
const bson_t *command;
const mongoc_read_prefs_t *read_prefs;
const bson_t *opts;
bson_t *reply;
bson_error_t *error;
CODE:
RETVAL = mongoc_collection_command_with_opts(collection, command, read_prefs, opts, reply, error);
OUTPUT:
RETVAL
mongoc_collection_t *
collection_copy(collection)
lib/Pongo/Client.xs view on Meta::CPAN
RETVAL = mongoc_collection_copy(collection);
OUTPUT:
RETVAL
int64_t
collection_count_documents(collection, filter, opts, read_prefs, reply, error)
mongoc_collection_t *collection;
const bson_t *filter;
const bson_t *opts;
const mongoc_read_prefs_t *read_prefs;
bson_t *reply;
bson_error_t *error;
CODE:
RETVAL = mongoc_collection_count_documents(collection, filter, opts, read_prefs, reply, error);
OUTPUT:
RETVAL
int64_t
collection_estimated_document_count(collection, opts, read_prefs, reply, error)
mongoc_collection_t *collection;
const bson_t *opts;
const mongoc_read_prefs_t * read_prefs;
bson_t *reply;
bson_error_t *error;
CODE:
RETVAL = mongoc_collection_estimated_document_count(collection, opts, read_prefs, reply, error);
OUTPUT:
RETVAL
int
collection_count(collection, flags, query, skip, limit, read_prefs, error)
mongoc_collection_t *collection;
int flags;
SV *query;
SV *skip;
SV *limit;
SV *read_prefs;
SV *error;
CODE:
mongoc_query_flags_t query_flag = (mongoc_query_flags_t) flags;
const bson_t *bson_query = (const bson_t *) SvIV(SvRV(query));
int64_t skip_value = SvIV(skip);
int64_t limit_value = SvIV(limit);
const mongoc_read_prefs_t *read_prefs_value = NULL;
if (SvOK(read_prefs)) {
read_prefs_value = (const mongoc_read_prefs_t*) SvIV(SvRV(read_prefs));
}
bson_error_t *bson_error = NULL;
if (SvOK(error)) {
bson_error = (bson_error_t*) SvIV(SvRV(error));
}
int64_t output = mongoc_collection_count(collection, query_flag, bson_query, skip_value, limit_value, read_prefs_value, bson_error);
RETVAL = (int) output;
OUTPUT:
RETVAL
int64_t
collection_count_with_opts(collection, flags, query,skip, limit, opts, read_prefs, error)
mongoc_collection_t *collection;
mongoc_query_flags_t flags;
const bson_t *query;
int64_t skip;
int64_t limit;
const bson_t *opts;
const mongoc_read_prefs_t *read_prefs;
bson_error_t *error;
CODE:
RETVAL = mongoc_collection_count_with_opts(collection, flags, query, skip, limit, opts, read_prefs, error);
OUTPUT:
RETVAL
mongoc_bulk_operation_t *
collection_create_bulk_operation(collection, ordered, write_concern)
lib/Pongo/Client.xs view on Meta::CPAN
RETVAL = mongoc_collection_ensure_index(collection, keys, opt, error);
OUTPUT:
RETVAL
mongoc_cursor_t *
collection_find(collection, flags, skip, limit, batch_size, query, fields, read_prefs)
mongoc_collection_t *collection;
int flags;
SV *skip;
SV *limit;
SV *batch_size;
SV *query;
SV *fields;
SV *read_prefs;
CODE:
mongoc_query_flags_t flag_value = (mongoc_query_flags_t)flags;
uint32_t skip_value = SvUV(skip);
uint32_t limit_value = SvUV(limit);
uint32_t batch_size_value = SvUV(batch_size);
lib/Pongo/Client.xs view on Meta::CPAN
if (SvOK(fields)) {
bson_fields = (const bson_t *) SvIV(SvRV(fields)); // Convert to BSON pointer
} else {
warn("Fields are invalid or undef");
}
const mongoc_read_prefs_t *read_prefs_value = NULL;
if (SvOK(read_prefs)) {
read_prefs_value = (const mongoc_read_prefs_t *) SvIV(SvRV(read_prefs)); // Dereference read_prefs
}
RETVAL = mongoc_collection_find(collection, flag_value, skip_value, limit_value, batch_size_value, bson_query, bson_fields, read_prefs_value);
OUTPUT:
RETVAL
bool
collection_find_and_modify(collection, query, sort, update, fields, _remove, upsert, _new, reply, error)
lib/Pongo/Client.xs view on Meta::CPAN
RETVAL = mongoc_collection_find_indexes_with_opts(collection, opts);
OUTPUT:
RETVAL
mongoc_cursor_t *
collection_find_with_opts(collection, filter, opts, read_prefs)
mongoc_collection_t *collection;
const bson_t *filter;
const bson_t *opts;
const mongoc_read_prefs_t *read_prefs;
CODE:
RETVAL = mongoc_collection_find_with_opts(collection, filter, opts, read_prefs);
OUTPUT:
RETVAL
const bson_t *
collection_get_last_error(collection)
lib/Pongo/Client.xs view on Meta::CPAN
CODE:
RETVAL = mongoc_collection_get_read_concern(collection);
OUTPUT:
RETVAL
const mongoc_read_prefs_t *
collection_get_read_prefs(collection)
const mongoc_collection_t *collection;
CODE:
RETVAL = mongoc_collection_get_read_prefs(collection);
OUTPUT:
RETVAL
const mongoc_write_concern_t *
collection_get_write_concern(collection)
lib/Pongo/Client.xs view on Meta::CPAN
RETVAL = mongoc_collection_keys_to_index_string(keys);
OUTPUT:
RETVAL
bool
collection_read_command_with_opts(collection, command, read_prefs, opts, reply, error)
mongoc_collection_t *collection;
const bson_t *command;
const mongoc_read_prefs_t *read_prefs;
const bson_t *opts;
bson_t *reply;
bson_error_t *error;
CODE:
RETVAL = mongoc_collection_read_command_with_opts(collection, command, read_prefs, opts, reply, error);
OUTPUT:
RETVAL
bool
collection_remove(collection, flags, selector, write_concern, error)
lib/Pongo/Client.xs view on Meta::CPAN
const mongoc_read_concern_t *read_concern;
CODE:
mongoc_collection_set_read_concern(collection, read_concern);
void
collection_set_read_prefs(collection, read_prefs)
mongoc_collection_t *collection;
const mongoc_read_prefs_t *read_prefs;
CODE:
mongoc_collection_set_read_prefs(collection, read_prefs);
void
collection_set_write_concern(collection, write_concern)
mongoc_collection_t *collection;
const mongoc_write_concern_t *write_concern;
lib/Pongo/Client.xs view on Meta::CPAN
RETVAL = mongoc_database_add_user(database, username, password, roles, custom_data, error);
OUTPUT:
RETVAL
mongoc_cursor_t *
database_aggregate(database, pipeline, opts, read_prefs)
mongoc_database_t *database;
const bson_t *pipeline;
const bson_t *opts;
const mongoc_read_prefs_t *read_prefs;
CODE:
RETVAL = mongoc_database_aggregate(database, pipeline, opts, read_prefs);
OUTPUT:
RETVAL
mongoc_cursor_t *
database_command(database, flags, skip, limit, batch_size, command, fields, read_prefs)
mongoc_database_t *database;
mongoc_query_flags_t flags;
uint32_t skip;
uint32_t limit;
uint32_t batch_size;
const bson_t *command;
const bson_t *fields;
const mongoc_read_prefs_t *read_prefs;
CODE:
RETVAL = mongoc_database_command(database, flags, skip, limit, batch_size, command, fields, read_prefs);
OUTPUT:
RETVAL
bool
database_command_simple(database, command, read_prefs, reply, error)
mongoc_database_t *database;
const bson_t *command;
const mongoc_read_prefs_t *read_prefs;
bson_t *reply;
bson_error_t *error;
CODE:
RETVAL = mongoc_database_command_simple(database, command, read_prefs, reply, error);
OUTPUT:
RETVAL
bool
database_command_with_opts(database, command, read_prefs, opts, reply, error)
mongoc_database_t *database;
const bson_t *command;
const mongoc_read_prefs_t *read_prefs;
const bson_t *opts;
bson_t *reply;
bson_error_t *error;
CODE:
RETVAL = mongoc_database_command_with_opts(database, command, read_prefs, opts, reply, error);
OUTPUT:
RETVAL
mongoc_database_t *
database_copy(database)
lib/Pongo/Client.xs view on Meta::CPAN
CODE:
RETVAL = mongoc_database_get_read_concern(database);
OUTPUT:
RETVAL
const mongoc_read_prefs_t *
database_get_read_prefs(database)
const mongoc_database_t *database;
CODE:
RETVAL = mongoc_database_get_read_prefs(database);
OUTPUT:
RETVAL
const mongoc_write_concern_t *
database_get_write_concern(database)
lib/Pongo/Client.xs view on Meta::CPAN
RETVAL = mongoc_database_has_collection(database, name, error);
OUTPUT:
RETVAL
bool
database_read_command_with_opts(database, command, read_prefs, opts, reply, error)
mongoc_database_t *database;
const bson_t *command;
const mongoc_read_prefs_t *read_prefs;
const bson_t *opts;
bson_t *reply;
bson_error_t *error;
CODE:
RETVAL = mongoc_database_read_command_with_opts(database, command, read_prefs, opts, reply, error);
OUTPUT:
RETVAL
bool
database_read_write_command_with_opts(database, command, read_prefs, opts, reply, error)
mongoc_database_t *database;
const bson_t *command;
const mongoc_read_prefs_t *read_prefs;
const bson_t *opts;
bson_t *reply;
bson_error_t *error;
CODE:
RETVAL = mongoc_database_read_write_command_with_opts(database, command, read_prefs, opts, reply, error);
OUTPUT:
RETVAL
bool
database_remove_all_users(database, error)
lib/Pongo/Client.xs view on Meta::CPAN
const mongoc_read_concern_t *read_concern;
CODE:
mongoc_database_set_read_concern(database, read_concern);
void
database_set_read_prefs(database, read_prefs)
mongoc_database_t *database;
const mongoc_read_prefs_t *read_prefs;
CODE:
mongoc_database_set_read_prefs(database, read_prefs);
void
database_set_write_concern(database, write_concern)
mongoc_database_t *database;
const mongoc_write_concern_t *write_concern;
lib/Pongo/Client.xs view on Meta::CPAN
RETVAL = mongoc_gridfs_bucket_find(bucket, filter, opts);
OUTPUT:
RETVAL
mongoc_gridfs_bucket_t *
gridfs_bucket_new(db, opts, read_prefs, error)
mongoc_database_t *db;
const bson_t *opts;
const mongoc_read_prefs_t *read_prefs;
bson_error_t *error;
CODE:
RETVAL = mongoc_gridfs_bucket_new(db, opts, read_prefs, error);
OUTPUT:
RETVAL
mongoc_stream_t *
gridfs_bucket_open_download_stream(bucket, file_id, error)
lib/Pongo/Client.xs view on Meta::CPAN
RETVAL = mongoc_read_concern_set_level(read_concern, level);
OUTPUT:
RETVAL
void
read_prefs_add_tag(read_prefs, tag)
mongoc_read_prefs_t *read_prefs;
const bson_t *tag;
CODE:
mongoc_read_prefs_add_tag(read_prefs, tag);
mongoc_read_prefs_t *
read_prefs_copy(read_prefs)
const mongoc_read_prefs_t *read_prefs;
CODE:
RETVAL = mongoc_read_prefs_copy(read_prefs);
OUTPUT:
RETVAL
void
read_prefs_destroy(read_prefs)
mongoc_read_prefs_t *read_prefs;
CODE:
mongoc_read_prefs_destroy(read_prefs);
const bson_t *
read_prefs_get_hedge(read_prefs)
const mongoc_read_prefs_t *read_prefs;
CODE:
RETVAL = mongoc_read_prefs_get_hedge(read_prefs);
OUTPUT:
RETVAL
int64_t
read_prefs_get_max_staleness_seconds(read_prefs)
const mongoc_read_prefs_t *read_prefs;
CODE:
RETVAL = mongoc_read_prefs_get_max_staleness_seconds(read_prefs);
OUTPUT:
RETVAL
mongoc_read_mode_t
read_prefs_get_mode(read_prefs)
const mongoc_read_prefs_t *read_prefs;
CODE:
RETVAL = mongoc_read_prefs_get_mode(read_prefs);
OUTPUT:
RETVAL
const bson_t *
read_prefs_get_tags(read_prefs)
const mongoc_read_prefs_t *read_prefs;
CODE:
RETVAL = mongoc_read_prefs_get_tags(read_prefs);
OUTPUT:
RETVAL
bool
read_prefs_is_valid(read_prefs)
const mongoc_read_prefs_t *read_prefs;
CODE:
RETVAL = mongoc_read_prefs_is_valid(read_prefs);
OUTPUT:
RETVAL
mongoc_read_prefs_t *
read_prefs_new(read_mode)
mongoc_read_mode_t read_mode;
CODE:
RETVAL = mongoc_read_prefs_new(read_mode);
OUTPUT:
RETVAL
void
read_prefs_set_hedge(read_prefs, hedge)
mongoc_read_prefs_t *read_prefs;
const bson_t *hedge;
CODE:
mongoc_read_prefs_set_hedge(read_prefs, hedge);
void
read_prefs_set_max_staleness_seconds(read_prefs, max_staleness_seconds)
mongoc_read_prefs_t *read_prefs;
int64_t max_staleness_seconds;
CODE:
mongoc_read_prefs_set_max_staleness_seconds(read_prefs, max_staleness_seconds);
void
read_prefs_set_mode(read_prefs, mode)
mongoc_read_prefs_t *read_prefs;
mongoc_read_mode_t mode;
CODE:
mongoc_read_prefs_set_mode(read_prefs, mode);
void
read_prefs_set_tags(read_prefs, tags)
mongoc_read_prefs_t *read_prefs;
const bson_t *tags;
CODE:
mongoc_read_prefs_set_tags(read_prefs, tags);
mongoc_server_api_t *
server_api_copy(api)
const mongoc_server_api_t *api;
CODE:
lib/Pongo/Client.xs view on Meta::CPAN
RETVAL = mongoc_topology_description_get_servers(td, n);
OUTPUT:
RETVAL
bool
topology_description_has_readable_server(td, prefs)
const mongoc_topology_description_t *td;
const mongoc_read_prefs_t *prefs;
CODE:
RETVAL = mongoc_topology_description_has_readable_server(td, prefs);
OUTPUT:
RETVAL
bool
topology_description_has_writable_server(td)
lib/Pongo/Client.xs view on Meta::CPAN
const mongoc_write_concern_t *write_concern;
CODE:
mongoc_transaction_opts_set_write_concern(opts, write_concern);
void
transaction_opts_set_read_prefs(opts, read_prefs)
mongoc_transaction_opt_t *opts;
const mongoc_read_prefs_t *read_prefs;
CODE:
mongoc_transaction_opts_set_read_prefs(opts, read_prefs);
mongoc_transaction_opt_t *
transaction_opts_new()
CODE:
RETVAL = mongoc_transaction_opts_new();
lib/Pongo/Client.xs view on Meta::CPAN
CODE:
RETVAL = mongoc_transaction_opts_get_write_concern(opts);
OUTPUT:
RETVAL
const mongoc_read_prefs_t *
transaction_opts_get_read_prefs(opts)
const mongoc_transaction_opt_t *opts;
CODE:
RETVAL = mongoc_transaction_opts_get_read_prefs(opts);
OUTPUT:
RETVAL
int64_t
transaction_opts_get_max_commit_time_ms(opts)
lib/Pongo/Client.xs view on Meta::CPAN
RETVAL = mongoc_uri_get_read_concern(uri);
OUTPUT:
RETVAL
const bson_t *
uri_get_read_prefs(uri)
const mongoc_uri_t *uri;
CODE:
RETVAL = mongoc_uri_get_read_prefs(uri);
OUTPUT:
RETVAL
const char *
uri_get_replica_set(uri)
lib/Pongo/Client.xs view on Meta::CPAN
const mongoc_read_concern_t *rc;
CODE:
mongoc_uri_set_read_concern(uri, rc);
void
uri_set_read_prefs(uri, prefs)
mongoc_uri_t *uri;
const mongoc_read_prefs_t *prefs;
CODE:
mongoc_uri_set_read_prefs_t(uri, prefs);
bool
uri_set_server_monitoring_mode(uri, value)
mongoc_uri_t *uri;
const char *value;
Portable
view release on metacpan or search on metacpan
t/data/portable.perl view on Meta::CPAN
histfile: cpan/histfile
keep_source_where: cpan/sources
make: c/bin/dmake.exe
makepl_arg: 'LIBS=-L$_libpthfix_part1 INC=-I$incpath'
patch: c/bin/patch.exe
prefs_dir: cpan/prefs
Env:
PATH:
- c/bin
- perl/bin
LIB:
Printer-EVOLIS
view release on metacpan or search on metacpan
inc/Module/Install/Repository.pm view on Meta::CPAN
if ($query_repo =~ m!Default Remote: (http://.+)!) {
return $1;
}
}
open my $handle, '<', '_darcs/prefs/repos' or return;
while (<$handle>) {
chomp;
return $_ if m!^http://!;
}
} elsif (-e ".hg") {
Proc-ProcessTable-ncps
view release on metacpan or search on metacpan
ldap 1379 0.0 0.03 194584576 11145216 SL uwait 0 172 20 4917 21-08:50 1:15 /usr/local/libexec/slapd -u ldap -g ldap
>ncps -p '>1'
User PID CPU MEM VSZ RSS Info Nic Pri Start Time Command
kitsune 51194 1.7 0.08 105558016 27037696 S select 0 132 21-20:08 15:57 xfreerdp /v:localhost /f -bitmap-cache
kitsune 27637 4.1 3.22 3684442112 1104576512 S select 0 138 21-17:21 57:38 /usr/local/lib/firefox/firefox -contentproc -childID 2 -isForBrowser -prefsLen
56 -prefMapSize 190709 -parentBuildID 20190807081812 -appdir
/usr/local/lib/firefox/browser 27293 tab
kitsune 27636 6.0 3.30 1591795712 1131040768 S select 0 138 21-17:21 2:2:6 /usr/local/lib/firefox/firefox -contentproc -childID 1 -isForBrowser -prefsLen 1
-prefMapSize 190709 -parentBuildID 20190807081812 -appdir
/usr/local/lib/firefox/browser 27293 tab
mysql 1914 2.9 2.08 1118347264 711675904 SL select 0 120 21-08:50 2:58:16 /usr/local/libexec/mysqld --defaults-extra-file=/usr/local/etc/percona/my.cnf
--basedir=/usr/local --datadir=/var/db/mysql
--plugin-dir=/usr/local/lib/mysql/plugin
Project-Libs
view release on metacpan or search on metacpan
inc/Module/Install/Repository.pm view on Meta::CPAN
if ($query_repo =~ m!Default Remote: (http://.+)!) {
return $1;
}
}
open my $handle, '<', '_darcs/prefs/repos' or return;
while (<$handle>) {
chomp;
return $_ if m!^http://!;
}
} elsif (-e ".hg") {
Promise-Me
view release on metacpan or search on metacpan
lib/Promise/Me.pm view on Meta::CPAN
my %preferences : shared;
my @names : shared;
=item 2. calling L</share>
my( $name, %prefs, @middle_names );
share( $name, %prefs, @middle_names );
=back
Once shared, you can use those variables normally and their values will be shared between the parent process and the asynchronous process.
lib/Promise/Me.pm view on Meta::CPAN
=head2 $SHARED_MEMORY_SIZE
This is the size in bytes of the shared memory block used for sharing variables between the main process and the sub processes. This is used when you share variables, such as:
my $name : shared;
my( $name, %prefs, @middle_names );
share( $name, %prefs, @middle_names );
See L</"SHARED VARIABLES">
=head2 $USE_THREADS_SHARED
Protocol-HTTP
view release on metacpan or search on metacpan
clib/src/panda/protocol/http/Request.cc view on Meta::CPAN
sz_host_port = 6;
}
}
string out_accept_encoding;
if (compression_prefs && compression_prefs != static_cast<compression::storage_t>(Compression::IDENTITY) && !headers.has("Accept-Encoding")) {
string comp_pos, comp_neg;
int index_pos = 0, index_neg = 0;
compression::for_each(compression_prefs, [&](auto value, bool negation){
const char* val = nullptr;
switch (value) {
case Compression::GZIP : val = "gzip"; break;
case Compression::BROTLI : val = "br"; break;
default: return;
clib/src/panda/protocol/http/Request.cc view on Meta::CPAN
return false;
}
std::uint8_t Request::allowed_compression (bool inverse) const noexcept {
std::uint8_t result = 0;
compression::for_each(compression_prefs, [&](auto value, bool negation){
if (inverse == negation) {
result |= value;
}
});
return result;
PurpleWiki
view release on metacpan or search on metacpan
DoEdit($id, 0, 0, "", 0) if ValidIdOrDie($id);
} elsif ($action eq "unlock") {
DoUnlock();
} elsif ($action eq "index") {
DoIndex();
} elsif ($action eq "editprefs") {
DoEditPrefs();
} elsif ($config->UseINames && $action eq "getiname") {
if (!$user) {
&DoGetIname();
}
my $rrsid = &GetParam("rrsid", "");
&DoAssociateIname($iname, $localId, $rrsid);
return;
}
if (&GetParam("edit_prefs", 0)) {
&DoUpdatePrefs();
return;
}
if (GetParam("enter_login", 0)) {
DoLogin();
sub globalTemplateVars {
return (siteName => $config->SiteName,
baseUrl => $config->ScriptName,
homePage => $config->HomePage,
userName => $user ? $user->username : undef,
preferencesUrl => $config->ScriptName . '?action=editprefs');
}
&DoWikiRequest() if ($config->RunCGI && ($_ ne 'nocgi')); # Do everything.
1; # In case we are loaded from elsewhere
# == End of UseModWiki script. ===========================================
QWizard
view release on metacpan or search on metacpan
Generator/HTML.pm view on Meta::CPAN
$self->add_handler('unknown',
\&QWizard::Generator::HTML::do_unknown,
[]);
$self->{'datastore'} = new QWizard::Storage::CGIParam;
$self->{'prefstore'} = new QWizard::Storage::CGICookie;
return $self;
}
sub init_cgi {
Generator/HTML.pm view on Meta::CPAN
sub init_screen {
my ($self, $wiz, $title) = @_;
$self->init_cgi();
return if ($self->{'started'} || $wiz->{'started'});
$self->{'started'} = $wiz->{'started'} = $self->{'prefstore'}{'started'} =1;
$self->{'first_tree'} = 1;
my @otherargs;
if ($self->{'cssurl'}) {
push @otherargs, 'style', { src => $self->{'cssurl'}};
} elsif (!$self->{'nocss'}) {
Generator/HTML.pm view on Meta::CPAN
print $self->{'cgi'}->start_html(-title => escapeHTML($title),
-bgcolor => $self->{'bgcolor'}
|| $wiz->{'bgcolor'} || "#ffffff",
@otherargs);
if ($self->{'prefstore'}->{'immediate_out'} &&
$#{$self->{'prefstore'}->{'immediate_out'}} > -1) {
print @{$self->{'prefstore'}->{'immediate_out'}};
delete $self->{'prefstore'}->{'immediate_out'};
}
print $self->{'cgi'}->start_multipart_form(-name => $self->{'form_name'}),
"\n";
$self->{'wizard'} = $wiz;
}
Qudo-Driver-DBI
view release on metacpan or search on metacpan
inc/Module/Install/Repository.pm view on Meta::CPAN
if ($query_repo =~ m!Default Remote: (http://.+)!) {
return $1;
}
}
open my $handle, '<', '_darcs/prefs/repos' or return;
while (<$handle>) {
chomp;
return $_ if m!^http://!;
}
} elsif (-e ".hg") {
Qudo-Hook-Notify
view release on metacpan or search on metacpan
inc/Module/Install/Repository.pm view on Meta::CPAN
if ($query_repo =~ m!Default Remote: (http://.+)!) {
return $1;
}
}
open my $handle, '<', '_darcs/prefs/repos' or return;
while (<$handle>) {
chomp;
return $_ if m!^http://!;
}
} elsif (-e ".hg") {
Qudo-Parallel-Manager
view release on metacpan or search on metacpan
inc/Module/Install/Repository.pm view on Meta::CPAN
if ($query_repo =~ m!Default Remote: (http://.+)!) {
return $1;
}
}
open my $handle, '<', '_darcs/prefs/repos' or return;
while (<$handle>) {
chomp;
return $_ if m!^http://!;
}
} elsif (-e ".hg") {
Qudo-Plugin-Logger
view release on metacpan or search on metacpan
inc/Module/Install/Repository.pm view on Meta::CPAN
if ($query_repo =~ m!Default Remote: (http://.+)!) {
return $1;
}
}
open my $handle, '<', '_darcs/prefs/repos' or return;
while (<$handle>) {
chomp;
return $_ if m!^http://!;
}
} elsif (-e ".hg") {
RDF-RDFa-Template
view release on metacpan or search on metacpan
inc/Module/Install/Repository.pm view on Meta::CPAN
if ($query_repo =~ m!Default Remote: (http://.+)!) {
return $1;
}
}
open my $handle, '<', '_darcs/prefs/repos' or return;
while (<$handle>) {
chomp;
return $_ if m!^http://!;
}
} elsif (-e ".hg") {
RDF-Trine-Node-Literal-XML
view release on metacpan or search on metacpan
inc/Module/Install/Repository.pm view on Meta::CPAN
if ($query_repo =~ m!Default Remote: (http://.+)!) {
return $1;
}
}
open my $handle, '<', '_darcs/prefs/repos' or return;
while (<$handle>) {
chomp;
return $_ if m!^http://!;
}
} elsif (-e ".hg") {
RDF-Trine-Store-File
view release on metacpan or search on metacpan
inc/Module/Install/Repository.pm view on Meta::CPAN
if ($query_repo =~ m!Default Remote: (http://.+)!) {
return $1;
}
}
open my $handle, '<', '_darcs/prefs/repos' or return;
while (<$handle>) {
chomp;
return $_ if m!^http://!;
}
} elsif (-e ".hg") {
REST-Application
view release on metacpan or search on metacpan
lib/REST/Application.pm view on Meta::CPAN
# original. Same with libwww's HTTP::Negotiate algorithim, it's also hard to
# make go with what we want.
sub getContentPrefs {
my $self = shift;
my $default_weight = 1;
my @prefs;
# Parse the Accept header, and save type name, score, and position.
my @accept_types = split /,/, $self->getAcceptHeader();
my $order = 0;
for my $accept_type (@accept_types) {
my ($weight) = ($accept_type =~ /q=(\d\.\d+|\d+)/);
my ($name) = ($accept_type =~ m#(\S+/[^;]+)#);
next unless $name;
push @prefs, { name => $name, order => $order++};
if (defined $weight) {
$prefs[-1]->{score} = $weight;
} else {
$prefs[-1]->{score} = $default_weight;
$default_weight -= 0.001;
}
}
# Sort the types by score, subscore by order, and pull out just the name
@prefs = map {$_->{name}} sort {$b->{score} <=> $a->{score} ||
$a->{order} <=> $b->{order}} @prefs;
return @prefs, '*/*'; # Allows allow for */*
}
sub getAcceptHeader {
my $self = shift;
return $self->query->http('accept') || "";
REST-Utils
view release on metacpan or search on metacpan
0.5 Tue Apr 24 14:14:41 EDT 2012
Fix for RT#72337: perl 5.12 gives "Use of uninitialized value in
uc ....' warnings." Thanks Paul W. Harvey for the patch.
0.4 Tue Aug 31 22:20:53 EDT 2010
Removed the content_prefs() function as it isn't really helpful.
Added some functions for parsing MIME types the right way.
Made media_type() use the new MIME type parsing internally.
RT-Authen-ExternalAuth
view release on metacpan or search on metacpan
html/Callbacks/ExternalAuth/Elements/Header/Head view on Meta::CPAN
% if ( $session{CurrentUser}->UserObj->__Value('Password') eq '*NO-PASSWORD*') {
<style>
#user-prefs-password {
display: none;
}
</style>
% }
<%INIT>
RT-Authen-Token
view release on metacpan or search on metacpan
html/Callbacks/RT-Authen-Token/Elements/Tabs/Privileged view on Meta::CPAN
<%INIT>
return unless $session{'CurrentUser'}->HasRight( Right => 'ManageAuthTokens', Object => RT->System );
if (my $prefs = Menu->child('preferences')) {
if (my $settings = $prefs->child('settings')) {
$settings->child('about_me')->add_after(auth_tokens => title => loc('Auth Tokens'), path => '/Prefs/AuthTokens.html');
}
}
my $admin = Menu->child('admin')
RT-Extension-AI
view release on metacpan or search on metacpan
html/Helpers/AISearch/GenerateTicketSQL view on Meta::CPAN
$parsed = JSON::decode_json($ai_response);
};
# Use default format when AI doesn't provide one
my $user_prefs = $session{'CurrentUser'}->UserObj->Preferences("SearchDisplay") || {};
my $default_search_format = $user_prefs->{'Format'} || RT->Config->Get('DefaultSearchResultFormat');
if ($@ || !$parsed) {
RT->Logger->warning("AI response was not valid JSON, attempting to extract TicketSQL. Error: $@");
RT->Logger->debug("Failed to parse as JSON, raw response was: $ai_response");
RT-Extension-ModifyUsersPrefs
view release on metacpan or search on metacpan
META.yml
po/fr.po
README
README.md
xt/00-load.t
xt/modify-users-prefs.t
SIGNATURE Public-key signature (added by MakeMaker)
RT-Extension-TOTPMFA
view release on metacpan or search on metacpan
html/Callbacks/TOTPMFA/Admin/Users/Modify.html/LeftColumnBottom view on Meta::CPAN
return if (not $UserObj->Privileged);
my $Settings = RT::Extension::TOTPMFA::UserSettings($UserObj);
</%INIT>
\
<&| /Widgets/TitleBox, title => loc('Multi-factor authentication'), id => "user-prefs-totpmfa" &>
<& /Elements/TOTPMFATypeSelector, Settings => $Settings &>
</&>
( run in 1.824 second using v1.01-cache-2.11-cpan-0bb4e1dffa6 )