view release on metacpan or search on metacpan
lib/CPANPLUS/Dist/Build.pm view on Meta::CPAN
related modules.
Using this package, you can create, install and uninstall perl
modules. It inherits from C<CPANPLUS::Dist>.
Normal users won't have to worry about the interface to this module,
as it functions transparently as a plug-in to C<CPANPLUS> and will
just C<Do The Right Thing> when it's loaded.
=head1 ACCESSORS
=over 4
view release on metacpan or search on metacpan
include/boost/container/detail/flat_tree.hpp view on Meta::CPAN
}
return i;
}
template<class K>
typename dtl::enable_if_transparent<key_compare, K, iterator>::type
find(const K& k)
{
iterator i = this->lower_bound(k);
iterator end_it = this->end();
if (i != end_it && this->m_data.get_comp()(k, KeyOfValue()(*i))){
include/boost/container/detail/flat_tree.hpp view on Meta::CPAN
}
return i;
}
template<class K>
typename dtl::enable_if_transparent<key_compare, K, const_iterator>::type
find(const K& k) const
{
const_iterator i = this->lower_bound(k);
const_iterator end_it = this->cend();
include/boost/container/detail/flat_tree.hpp view on Meta::CPAN
size_type n = p.second - p.first;
return n;
}
template<class K>
typename dtl::enable_if_transparent<key_compare, K, size_type>::type
count(const K& k) const
{
std::pair<const_iterator, const_iterator> p = this->equal_range(k);
size_type n = p.second - p.first;
return n;
include/boost/container/detail/flat_tree.hpp view on Meta::CPAN
BOOST_CONTAINER_FORCEINLINE const_iterator lower_bound(const key_type& k) const
{ return this->priv_lower_bound(this->cbegin(), this->cend(), k); }
template<class K>
BOOST_CONTAINER_FORCEINLINE
typename dtl::enable_if_transparent<key_compare, K, iterator>::type
lower_bound(const K& k)
{ return this->priv_lower_bound(this->begin(), this->end(), k); }
template<class K>
BOOST_CONTAINER_FORCEINLINE
typename dtl::enable_if_transparent<key_compare, K, const_iterator>::type
lower_bound(const K& k) const
{ return this->priv_lower_bound(this->cbegin(), this->cend(), k); }
BOOST_CONTAINER_FORCEINLINE iterator upper_bound(const key_type& k)
{ return this->priv_upper_bound(this->begin(), this->end(), k); }
include/boost/container/detail/flat_tree.hpp view on Meta::CPAN
BOOST_CONTAINER_FORCEINLINE const_iterator upper_bound(const key_type& k) const
{ return this->priv_upper_bound(this->cbegin(), this->cend(), k); }
template<class K>
BOOST_CONTAINER_FORCEINLINE
typename dtl::enable_if_transparent<key_compare, K,iterator>::type
upper_bound(const K& k)
{ return this->priv_upper_bound(this->begin(), this->end(), k); }
template<class K>
BOOST_CONTAINER_FORCEINLINE
typename dtl::enable_if_transparent<key_compare, K,const_iterator>::type
upper_bound(const K& k) const
{ return this->priv_upper_bound(this->cbegin(), this->cend(), k); }
BOOST_CONTAINER_FORCEINLINE std::pair<iterator,iterator> equal_range(const key_type& k)
{ return this->priv_equal_range(this->begin(), this->end(), k); }
include/boost/container/detail/flat_tree.hpp view on Meta::CPAN
BOOST_CONTAINER_FORCEINLINE std::pair<const_iterator, const_iterator> equal_range(const key_type& k) const
{ return this->priv_equal_range(this->cbegin(), this->cend(), k); }
template<class K>
BOOST_CONTAINER_FORCEINLINE
typename dtl::enable_if_transparent<key_compare, K,std::pair<iterator,iterator> >::type
equal_range(const K& k)
{ return this->priv_equal_range(this->begin(), this->end(), k); }
template<class K>
BOOST_CONTAINER_FORCEINLINE
typename dtl::enable_if_transparent<key_compare, K,std::pair<const_iterator,const_iterator> >::type
equal_range(const K& k) const
{ return this->priv_equal_range(this->cbegin(), this->cend(), k); }
BOOST_CONTAINER_FORCEINLINE std::pair<iterator, iterator> lower_bound_range(const key_type& k)
include/boost/container/detail/flat_tree.hpp view on Meta::CPAN
BOOST_CONTAINER_FORCEINLINE std::pair<const_iterator, const_iterator> lower_bound_range(const key_type& k) const
{ return this->priv_lower_bound_range(this->cbegin(), this->cend(), k); }
template<class K>
BOOST_CONTAINER_FORCEINLINE
typename dtl::enable_if_transparent<key_compare, K,std::pair<iterator,iterator> >::type
lower_bound_range(const K& k)
{ return this->priv_lower_bound_range(this->begin(), this->end(), k); }
template<class K>
BOOST_CONTAINER_FORCEINLINE
typename dtl::enable_if_transparent<key_compare, K,std::pair<const_iterator,const_iterator> >::type
lower_bound_range(const K& k) const
{ return this->priv_lower_bound_range(this->cbegin(), this->cend(), k); }
BOOST_CONTAINER_FORCEINLINE size_type capacity() const
{
view release on metacpan or search on metacpan
0.12 CHANGES:
* Some initial work on CPS::Future
0.11 CHANGES:
* Added kpareach()
* Renamed kloop() to kwhile(); added transparent back-compatibility
redirect
0.10 CHANGES:
* Moved data-flow functional functions into their own CPS::Functional
namespace
view release on metacpan or search on metacpan
t/data/zx48.asm view on Meta::CPAN
; 23695 |___|___|___|___|___|___|___|___|
; 7 6 5 4 3 2 1 0
;
;
; {fl}{br}{ paper }{ ink } The temporary mask used for
; ___ ___ ___ ___ ___ ___ ___ ___ transparent colours. Any bit
; MASK_T | | | | | | | | | that is 1 shows that the
; | | | | | | | | | corresponding attribute is
; 23696 |___|___|___|___|___|___|___|___| taken not from ATTR-T but from
; 7 6 5 4 3 2 1 0 what is already on the screen.
;
view release on metacpan or search on metacpan
lib/CSS/Adaptor/Whitelist.pm view on Meta::CPAN
my $re_frac = qr/ \d* \. \d+ | \d+ \.? /x;
my $re_dim = qr/ $re_percent | (?:$re_frac) (?:p[ctx]|in|[cem]m|ex) \b | 0 \b /x;
my $re_ndim = qr/(?:-?$re_dim)/;
my $re_color_name = qr/(?i-xsm:\b(?:A(?:qua(?:marine)?|(?:liceBlu|ntiqueWhit|zur)e)|B(?:l(?:a(?:ck|nchedAlmond)|ue(?:Violet)?)|(?:eig|isqu)e|rown|urlyWood)|C(?:h(?:artreus|ocolat)e|or(?:n(?:flowerBlue|silk)|al)|adetBlue|(?:rimso|ya)n)|D(?:ark(?:G(?:r...
my $re_color = qr/(?:
transparent \b
| $re_color_name # Blue
| \#[\da-fA-F]{6} \b # #FF00FF
| \#[\da-fA-F]{3} \b # #F0F
| rgb\( # rgb(255,0,255), rgb(255,0,255,0.3)
(?: \d{1,3} | $re_percent ),
view release on metacpan or search on metacpan
t/data/layout.css view on Meta::CPAN
font-family: sans-serif;
}
#wrapper{
margin: 0;
background-color: transparent;
padding: 0em;
position: relative;
}
a:hover{ color: red; }
t/data/layout.css view on Meta::CPAN
text-align: right ! important;
padding: 0em 0em 1em 0em;
}
.listing .odd {
/*every second line should be shaded */
background-color: transparent;
}
.listing .even {
background-color: #ededed;
}
.listing .listingCheckbox {
view release on metacpan or search on metacpan
lib/CSS/DOM/PropertyParser.pm view on Meta::CPAN
=begin comment
Colour names:
perl -MRegexp::Assemble -le 'my $ra = new Regexp::Assemble; $ra->add($_) for qw " transparent aliceblue antiquewhite aqua aquamarine azure beige bisque black blanchedalmond blue blueviolet brown burlywood cadetblue chartreuse chocolate coral cornflow...
perl -MRegexp::Assemble -le 'my $ra = new Regexp::Assemble; $ra->add($_) for qw " activeborder activecaption appworkspace background buttonface buttonhighlight buttonshadow buttontext captiontext graytext highlight highlighttext inactiveborder inacti...
=end comment
lib/CSS/DOM/PropertyParser.pm view on Meta::CPAN
inherit => 0,
},
'background-color' => {
format => '<colour>',
default => 'transparent',
inherit => 0,
},
'background-image' => {
format => '<url> | none',
view release on metacpan or search on metacpan
t/less/css.css view on Meta::CPAN
p, p:first-child { text-transform: none; }
q:lang(no) { quotes: none; }
p + h1 { font-size: 2.2em; }
input[type="text"] { font-weight: normal; }
h2[title] { font-size: 100%; }
[disabled] { color: transparent; }
#shorthands {
border: 1px solid #000000;
font: 12px/16px Arial;
margin: 1px 0;
padding: 0 auto;
view release on metacpan or search on metacpan
lib/CSS/Prepare/Property/Values.pm view on Meta::CPAN
}x;
# descriptive value types
our $background_attachment_value = qr{ (?: scroll | fixed | inherit ) }x;
our $background_colour_value
= qr{ (?: transparent | inherit | $colour_value ) }x;
our $background_image_value = qr{ (?: none | inherit | $url_value ) }x;
our $background_repeat_value
= qr{ (?: repeat | repeat-x | repeat-y | no-repeat | inherit ) }x;
my $background_positions_horizontal
= qr{ (?: left | center | centre | right ) }x;
lib/CSS/Prepare/Property/Values.pm view on Meta::CPAN
inherit
)
}x;
my $border_collapse_value = qr{ (?: collapse | separate | inherit ) }x;
our $border_colour_value = qr{ (?: transparent | inherit | $colour_value ) }x;
our $individual_border_radius_value
= qr{ (?: $positive_length_value | $positive_percentage_value ) }x;
our $border_radius_corner_value = qr{
$individual_border_radius_value
(?: \s+ $individual_border_radius_value )?
view release on metacpan or search on metacpan
lib/CSS/Sass/Type.pm view on Meta::CPAN
my $r = ${$_[0]}->{'r'};
my $g = ${$_[0]}->{'g'};
my $b = ${$_[0]}->{'b'};
my $a = ${$_[0]}->{'a'};
unless (defined $a && $a != 0) {
"transparent"
} elsif (defined $a && $a != 1) {
sprintf("rgba(%s, %s, %s, %s)", $r, $g, $b, $a)
} elsif ($r || $g || $b) {
sprintf("rgb(%s, %s, %s)", $r, $g, $b)
} else {
view release on metacpan or search on metacpan
t/02-scopify-groups.t view on Meta::CPAN
}
a {
text-decoration: underline;
}
* {
background: transparent!important;
box-shadow: none!important;
color: #000!important;
text-shadow: none!important;
}
t/02-scopify-groups.t view on Meta::CPAN
}
div.foo a {
text-decoration: underline;
}
div.foo * {
background: transparent!important;
box-shadow: none!important;
color: #000!important;
text-shadow: none!important;
}
view release on metacpan or search on metacpan
lib/CSS/SpriteBuilder.pm view on Meta::CPAN
max_image_width => DEF_MAX_IMAGE_WIDTH,
max_image_height => DEF_MAX_IMAGE_HEIGHT,
max_sprite_width => DEF_MAX_SPRITE_WIDTH,
max_sprite_height => DEF_MAX_SPRITE_HEIGHT,
margin => DEF_MARGIN,
transparent_color => undef,
is_background => 0,
layout => DEF_LAYOUT,
css_selector_prefix => DEF_CSS_SELECTOR_PREFIX,
css_url_prefix => '',
is_add_timestamp => 1,
lib/CSS/SpriteBuilder.pm view on Meta::CPAN
=item * B<margin> [ = 0 ]
Add margin to each image.
=item * B<transparent_color> [ = undef ]
Set transparent color for image, for example: 'white', 'black', ....
=item * B<is_background> [ = 0 ]
If B<is_background> flag is '0' will be generated CSS rule such as: 'width:XXXpx;height:YYYpx;'.
view release on metacpan or search on metacpan
lib/CSS/SpriteMaker.pm view on Meta::CPAN
if (my $err = $Target->ReadImage('xc:white')) {
warn $err;
}
$Target->Set(type => 'TruecolorMatte');
# make it transparent
$self->_verbose(" - clearing canvas");
$Target->Draw(
fill => 'transparent',
primitive => 'rectangle',
points => sprintf("0,0 %s,%s", $Layout->width(), $Layout->height())
);
$Target->Transparent('color' => 'white');
view release on metacpan or search on metacpan
lib/Graph.pm view on Meta::CPAN
horAxisLabel => 'delta (added or modified files)',
vertAxisLabel => 'size (nb files)',
);
$img->draw();
my $gd = $img->getGDobject();
$gd->transparent(-1);
return $gd;
}
sub EnergyCv {
my $cvs_log = shift;
view release on metacpan or search on metacpan
lib/CWB/Web/Cache.pm view on Meta::CPAN
##
## The CWB::Web::Cache module can also execute simple CQP queries and make their results
## persistent. The query results are identified by corpus, query string, and an optional sort
## (stored as metadata) rather than a single unique identifier, and can be shared among different
## processes using the same cache directory. When a persistent query result has expired from the
## cache, it is re-created in a way transparent to the calling program (by re-executing the query
## expression in the CQP process).
##
## The cache directory contains two subdirectories and an optional CONFIG file:
## index/ ... text files as 'markers' for cached queries (may contain 'metadata' about the cached query)
## data/ ... named query results stored in CQP's internal format
lib/CWB/Web/Cache.pm view on Meta::CPAN
$cqp = new CWB::CQP;
$cache = new CWB::Web::Cache -cqp => $cqp, -cachedir => $dir,
[-cachesize => $cache_size,] [-cachetime => $expiration_time];
# transparently execute and cache simple CQP queries
$id = $cache->query(-corpus => "DICKENS", -query => '[pos="NN"] "of" "England"');
($size) = $cqp->exec("size $id");
# optional features: sort clause, set keyword, subquery, and maximal number of matches
$id = $cache->query(
lib/CWB/Web/Cache.pm view on Meta::CPAN
Note that a B<CWB::Web::Cache> handle must be created with a pre-initialised CQP backend (i.e.
a B<CWB::CQP> object), which will be used to access the cache and (re-)run a query when necessary.
Most scripts will access the cache through the B<query()> method, which executes and caches CQP queries
in a fully transparent way (with optional C<sort> clause, C<set keyword> command, subquery,
and C<cut> to limit the maximal number of matches). After successful execution, the query result is
loaded into the CQP backend, the appropriate corpus is activated, and the I<$id> of the named query is
returned.
The C<sort> clause is executed I<after> a C<set keyword> command
view release on metacpan or search on metacpan
html/intro.html view on Meta::CPAN
<ul>
<li>CaCOREperl itself is not a data store, but a delegate to the caCORE server.
<li>CaCOREperl encapsulates the gory details of webservice call to the caCORE server, and serializing/deserializing
of domain objects.
<li>Communication with caCORE server is transparent to the user.
</ul>
<h2><a name="installing">Installing CaCOREperl</a></h2>
Perl comes installed on Unix and Linux platforms. For window based systems, you can download
view release on metacpan or search on metacpan
lib/Cache/SharedMemoryBackend.pm view on Meta::CPAN
return $share;
}
# this method uses the shared created by Instantiate_Share to
# transparently retrieve a reference to a shared hash structure
sub _Restore_Shared_Hash_Ref
{
my ( $p_ipc_identifier ) = Static_Params( @_ );
lib/Cache/SharedMemoryBackend.pm view on Meta::CPAN
return Thaw_Data( $frozen_hash_ref );
}
# this method uses the shared created by Instantiate_Share to
# transparently retrieve a reference to a shared hash structure, and
# additionally exclusively locks the share
sub _Restore_Shared_Hash_Ref_With_Lock
{
my ( $p_ipc_identifier ) = Static_Params( @_ );
lib/Cache/SharedMemoryBackend.pm view on Meta::CPAN
return Thaw_Data( $frozen_hash_ref );
}
# this method uses the shared created by Instantiate_Share to
# transparently persist a reference to a shared hash structure
sub _Store_Shared_Hash_Ref
{
my ( $p_ipc_identifier, $p_hash_ref ) = @_;
lib/Cache/SharedMemoryBackend.pm view on Meta::CPAN
_Instantiate_Share( $p_ipc_identifier )->store( Freeze_Data( $p_hash_ref ) );
}
# this method uses the shared created by Instantiate_Share to
# transparently persist a reference to a shared hash structure and
# additionally unlocks the share
sub _Store_Shared_Hash_Ref_And_Unlock
{
my ( $p_ipc_identifier, $p_hash_ref ) = @_;
view release on metacpan or search on metacpan
lib/Cache/CacheFactory.pm view on Meta::CPAN
Pruning and validity policies are set on a per-cache basis rather than
on a per-storage-policy basis, this makes multiple storage policies
largely pointless for most purposes where you'd find it useful.
If you wanted the cache to transparently use a small fast memory cache
first and fall back to a larger slower file cache as backup: you can't
do it, because the size pruning policy would be the same for both storage
policies.
About the only current use of multiple storage policies is to have a
view release on metacpan or search on metacpan
lib/Cache/Cascade.pm view on Meta::CPAN
For example, caching in a FastMmap based storage is much slower than using a
memory based cache, because pages must be locked to ensure that no corruption
will happen. Likewise Memcached is even more overhead than FastMmap because it
is network bound, and uses blocking IO (on the client side).
This module attempts to make a transparent cascade of caches using several
backends.
The idea is to search from the cheapest backend to the most expensive, and
depending on the options also cache results in the cheaper backends.
view release on metacpan or search on metacpan
lib/Cache/Memcached/Fast.pm view on Meta::CPAN
$memd->set($key, $value, $expiration_time);
Store the I<$value> on the server under the I<$key>. I<$key> should
be a scalar. I<$value> should be defined and may be of any Perl data
type. When it is a reference, the referenced Perl data structure will
be transparently serialized by routines specified with
L</serialize_methods>, which see.
Optional I<$expiration_time> is a positive integer number of seconds
after which the value will expire and wouldn't be accessible any
longer.
view release on metacpan or search on metacpan
lib/Cache/Memcached/Managed.pm view on Meta::CPAN
2D3H
means 2 days and 3 hours, which means B<183600> seconds.
=head2 transparent fork handling
Using this module, you do not have to worry if everything will still work
after a fork(). As soon as it is detected that the process has forked, new
handles will be opened to the memcached servers in the child process (so the
meticulous calling of "disconnect_all" of L<Cache::Memcached> is no longer
view release on metacpan or search on metacpan
=head1 DESCRIPTION
This module implements a shared data cache, using memory mapped files.
If routines are provided which interact with the underlying data, access to
the cache is completely transparent, and the module handles all the details of
refreshing cache contents, and updating underlying data, if necessary.
Cache entries are assigned to "buckets" within the cache file, depending on
the key. Within each bucket, entries are stored approximately in order of last
access, so that frequently accessed entries will move to the head of the
view release on metacpan or search on metacpan
lib/Cache/RedisDB.pm view on Meta::CPAN
Cache::RedisDB - RedisDB based cache system
=head1 DESCRIPTION
This is just a wrapper around RedisDB to have a single Redis object and connection per process. By default uses server redis://127.0.0.1, but it may be overwritten by REDIS_CACHE_SERVER environment variable. It transparently handles forks.
=head1 COMPATIBILITY AND REQUIREMENTS
Redis 2.6.12 and higher strongly recommended. Required if you want to use
extended options in ->set().
view release on metacpan or search on metacpan
examples/css/bootstrap-responsive.css view on Meta::CPAN
float: none;
display: block;
max-width: none;
margin: 0 15px;
padding: 0;
background-color: transparent;
border: none;
-webkit-border-radius: 0;
-moz-border-radius: 0;
border-radius: 0;
-webkit-box-shadow: none;
view release on metacpan or search on metacpan
Schedule.pm view on Meta::CPAN
# more examples in "Example entries" section
=head1 DESCRIPTION
The module is created with a purpose to provide functionality for handling a
personal calendar schedule in a transparent and simple way. The calendar
data is assumed to be kept in a plain file in a format easy to edit and
understand. It was inspired by the C<calendar> program on older Unix-like
systems, which used C<~/.calendar> file to produce entries for each day
and send them in the morning by email.
view release on metacpan or search on metacpan
static/orig/css/blueprint/print.css view on Meta::CPAN
blockquote {margin:1.5em;padding:1em;font-style:italic;font-size:.9em;}
.small {font-size:.9em;}
.large {font-size:1.1em;}
.quiet {color:#999;}
.hide {display:none;}
a:link, a:visited {background:transparent;font-weight:700;text-decoration:underline;}
a:link:after, a:visited:after {content:" (" attr(href) ")";font-size:90%;}
view release on metacpan or search on metacpan
doc/catalog.texinfo view on Meta::CPAN
After a while, you will want to reload a new version of the dmoz.org
data. It can be done using the same commands. The problem is that while
you do that the catalog will be unavailable to the users. The data are
first removed and then populated. Catalog does not currently offer support
for user transparent reloading. Instead we suggest you follow these steps:
@itemize @bullet
@item
Load dmoz on another machine.
view release on metacpan or search on metacpan
lib/Catalyst/Controller/REST.pm view on Meta::CPAN
Catalyst::Controller::REST implements a mechanism for building
RESTful services in Catalyst. It does this by extending the
normal Catalyst dispatch mechanism to allow for different
subroutines to be called based on the HTTP Method requested,
while also transparently handling all the serialization/deserialization for
you.
This is probably best served by an example. In the above
controller, we have declared a Local Catalyst action on
"sub thing", and have used the ActionClass('REST').
view release on metacpan or search on metacpan
lib/Catalyst/Controller/JMS.pm view on Meta::CPAN
=head1 DESCRIPTION
This controller base class makes it easy to handle JMS-style messages
in your Catalyst application. It handles deserialisation and
serialisation transparently (thanks to
L<Catalyst::Action::Deserialize> and L<Catalyst::Action::Serialize>)
and sets up the attributes needed by L<Catalyst::ActionRole::JMS>. It
also sets up some sensible default configuration.
=head1 CONFIGURATION
view release on metacpan or search on metacpan
lib/Catalyst/Controller/MovableType.pm view on Meta::CPAN
Captures the path of the Movable Type.
=head2 run_mt_script
Runs the requested Movable Type .cgi script transparently with cgi_to_response.
=head2 not_found
Sets the response to a simple 404 Not found page. You can override this method
with your own.