transparent results from the CPAN

Exported by default.

Enables aliasing semantics within the expression or block.  Returns an alias 
to the expression, or the block's return value.

C<alias> is context-transparent, meaning that whichever context it is placed in 
(list, scalar, void), the expression/block is evaluated in the same context.

=head2 copy I<EXPR> | copy I<BLOCK>

Restores normal (copying) semantics within the expression or block, and 
makes a copy of the result value (unless in void context).

Like C<alias>, C<copy> is context-transparent.

=head2 deref I<LIST>

Accepts a list of references to scalars, arrays, or hashes.  Applies the 
applicable dereferencing operator to each.  This means that:

view all matches for this distribution

Data-AnyXfer

1 match

lib/Data/AnyXfer/Elastic/Import/Storage/Directory.pm view on Meta::CPAN

Optional. The temporary directory data should be written to as operations are performed
on this instance.

=item B<item_file_suffix>

Optional. A string that will be appended to the end of every item name transparently
when written to storage (will not be visible through the storage interface).

You can also use this for file extensions.

=item B<item_file_prefix>

Optional. A string that will be prepended to the start of every item name transparently
when written to storage (will not be visible through the storage interface).

=back

=head1 STORAGE INTERFACE

lib/Data/AnyXfer/Elastic/Import/Storage/Directory.pm view on Meta::CPAN


Converts an arbritrary string to a format safe to be used by this storage
backend as an item name.

This is not necessary on storage interface methods as this is handled
transparently for you.

=head3 CAVEATS

This convertion is most likely one-way (lossy). Because of the normalisation,
different strings can point to the same item,

view all matches for this distribution

Data-BitStream

1 match

lib/Data/BitStream/BLVec.pm view on Meta::CPAN

This document only describes the unique features of this implementation,
which is of limited value to people purely using L<Data::BitStream>.

This implementation points everything to the implementations in
Data::BitStream::XS where possible.  This gives the majority of the performance
benefit of the XS module, while (1) transparently applying the speedup through
the Data::BitStream package, and (2) allowing all the Moo/Mouse/Moose extensions
and extra roles to be used while still retaining high performance at the core.

This is the default L<Data::BitStream> implementation if Data::BitStream::XS
is installed.

view all matches for this distribution

Data-CTable

2 results

CTable.pm view on Meta::CPAN

to be operated on.  Select() and sort() methods manipulate the
selection list.  Later, you can optionally rewrite the table in memory
or on disk to reflect changes in the selection list or field list.

Data::CTable reads and writes any tabular text file format including
Merge, CSV, Tab-delimited, and variants.  It transparently detects,
reads, and preserves Unix, Mac, and/or DOS line endings and tab or
comma field delimiters -- regardless of the runtime platform.

In addition to reading data files, CTable is a good way to gather,
store, and operate on tabular data in memory, and to export data to

view all matches for this distribution

Data-Dump-HTML-PopUp

1 match

share/modally-1.1.0/jquery.modally.css view on Meta::CPAN

    margin: 0;
    padding: 0;
    overflow: visible;
    cursor: pointer;

    background: transparent;

	position: absolute;
    top: 0px;
    right: 0px;
    padding: 12px 20px;

view all matches for this distribution

Data-Dumper-Interp

3 results

lib/Data/Dumper/Interp.pm view on Meta::CPAN

  $trunctailwidth = min($trunctailwidth//0, $maxstringwidth);
  $ovopt = "tagged";
  if (ref($objects) eq "HASH") {
    foreach my $key (keys %$objects) {
      if ($key eq 'show_classname') { # DEPRECATED
        $ovopt = $objects->{$key} ? "tagged" : "transparent"
      }
      elsif ($key eq 'overloads') {
        if (!defined($objects->{$key})) {
          $ovopt = "tagged";
        }
        elsif ($objects->{$key} =~ /^(?:tagged|transparent|ignore)$/) {
          $ovopt = $objects->{$key}
        }
        else { confess "Invalid 'overloads' sub-opt value '$objects->{$key}'" }
      }
      elsif ($key eq 'objects') { }

lib/Data/Dumper/Interp.pm view on Meta::CPAN


=over

B<overloads =E<gt> "tagged"> (the default): "(classname)" is prepended to the result when an overloaded operator is evaluated.

B<overloads =E<gt> "transparent"> : The overload results
will appear unadorned, i.e. they will look as if the overload result
was the original value.

B<overloads =E<gt> "ignore"> : Overloaded operators are not evaluated at all;
the original object's abbreviated refaddr is shown
(if you want to see object internals, disable I<Objects> entirely.)

Deprecated: B<show_classname =E<gt> False> : Please use S<< B<overloads =E<gt> "transparent"> instead. >>

=back

The I<objects> value indicates whether and for which classes special
object handling is enabled (false, "1", "classname" or [list of classnames]).

view all matches for this distribution

Data-Enumerable-Lazy

2 results

lib/Data/Enumerable/Lazy.pm view on Meta::CPAN

Creates a new enumerable by extending the existing one. on_next is
the only manfatory argument. on_has_next might be overriden if some
custom logic comes into play.

is_finite is inherited from the parent enumerable by default. All additional
attributes would be transparently passed to the constuctor.

=cut

sub continue {
  my ($this, $ext) = @_;

view all matches for this distribution

Data-Feed

1 match

lib/Data/Feed/RSS.pm view on Meta::CPAN

        $f->{'xml:base'} = shift;
    }
    return $f->{'xml:base'};
}

## The following all work transparently in any RSS version.
sub language {
    my $feed = shift->feed;

    if (@_) {
        $feed->channel('language', $_[0]);

view all matches for this distribution

Data-ICal

1 match

     CATEGORIES:BUSINESS,HUMAN RESOURCES
     END:VEVENT

   The following is an example of the "VEVENT" calendar component used
   to represent a reminder that will not be opaque, but rather
   transparent, to searches for busy time:

     BEGIN:VEVENT
     UID:19970901T130000Z-123402@host.com
     DTSTAMP:19970901T1300Z
     DTSTART:19970401T163000Z

   calendar date.

   The "VJOURNAL" calendar component does not take up time on a
   calendar. Hence, it does not play a role in free or busy time
   searches - - it is as though it has a time transparency value of
   TRANSPARENT. It is transparent to any such searches.

   The "VJOURNAL" calendar component cannot be nested within another
   calendar component. However, "VJOURNAL" calendar components can be
   related to each other or to a "VEVENT" or to a "VTODO" calendar
   component, with the "RELATED-TO" property.


4.8.2.7 Time Transparency

   Property Name: TRANSP

   Purpose: This property defines whether an event is transparent or not
   to busy time searches.

   Value Type: TEXT

   Property Parameters: Non-standard property parameters can be

     transvalue = "OPAQUE"      ;Blocks or opaque on busy time searches.
                / "TRANSPARENT" ;Transparent on busy time searches.
        ;Default value is OPAQUE

   Example: The following is an example of this property for an event
   that is transparent or does not block on free/busy time searches:

     TRANSP:TRANSPARENT

   The following is an example of this property for an event that is
   opaque or blocks on free/busy time searches:

view all matches for this distribution

Data-Locations

2 results

Locations.pm view on Meta::CPAN


You can also think of "C<Data::Locations>" as bubbles and bubbles inside
of other bubbles. You can inflate these bubbles in any arbitrary order
you like through a straw (i.e., the bubble's object reference).

Note that this module handles your data completely transparently, which
means that you can use it equally well for text AND binary data.

You might also be interested in knowing that this module and its concept
have already been heavily used in the automatic code generation of large
software projects.

view all matches for this distribution

Data-MessagePack-Stream

3 results

msgpack-3.3.0/Doxyfile view on Meta::CPAN

# code bases. Also note that the size of a graph can be further restricted by
# DOT_GRAPH_MAX_NODES. Using a depth of 0 means no depth restriction.

MAX_DOT_GRAPH_DEPTH    = 0

# Set the DOT_TRANSPARENT tag to YES to generate images with a transparent
# background. This is disabled by default, because dot on Windows does not
# seem to support this out of the box. Warning: Depending on the platform used,
# enabling this option may lead to badly anti-aliased labels on the edges of
# a graph (i.e. they become hard to read).

view all matches for this distribution

Data-Miscellany

2 results

lib/Data/Miscellany.pm view on Meta::CPAN


=head2 is_defined(SCALAR)

A kind of C<defined()> that is aware of L<Class::Value>, which has its own
views of what is a defined value and what isn't. The issue arose since
L<Class::Value> objects are supposed to be used transparently, mixed with
normal scalar values. However, it is not possible to overload "definedness",
and C<defined()> used on a value object always returns true since the
object reference certainly exists. However, what we want to know is
whether the value encapsulated by the value object is defined.
Additionally, each value class can have its own ideas of when its

view all matches for this distribution

Data-MuFormX-Registry

1 match

lib/Data/MuFormX/Registry.pm view on Meta::CPAN

classes.  At its heart it makes it so you don't have to say 'use Form;' for
every form you need in a package.  It also adds a way to centralize some
form initialization work.  This may or may not recommend itself to you.  I
think it makes it easier to reuse forms in different packages (for example in
different L<Mojolicous> controllers).  On the other hand it injects a proxy
layer such that '$registry->create("Login")' is not 100% transparent in that
you are getting an instance of 'MyApp::Form::Login'.  You may consider this
a type of action at a distance that makes your code harder to maintain.

If you have a lot of L<Data::MuForm> based form validation classes you may find
it more useful.  I also believe it helps you follow the 'code against an interface

view all matches for this distribution

Data-ObjectDriver

6 results

lib/Data/ObjectDriver.pm view on Meta::CPAN

1;
__END__

=head1 NAME

Data::ObjectDriver - Simple, transparent data interface, with caching

=head1 SYNOPSIS

    ## Set up your database driver code.
    package FoodDriver;

view all matches for this distribution

Data-ObjectStore

1 match

lib/Data/ObjectStore.pm view on Meta::CPAN


package Data::ObjectStore::Array;


##################################################################################
# This module is used transparently by ObjectStore to link arrays into its graph #
# structure. This is not meant to be called explicitly or modified.              #
##################################################################################

use strict;
use warnings;

lib/Data/ObjectStore.pm view on Meta::CPAN

# --------------------------------------------------------------------------------

package Data::ObjectStore::Hash;

##################################################################################
# This module is used transparently by ObjectStore to link hashes into its       #
# graph structure. This is not meant to  be called explicitly or modified.       #
##################################################################################

use strict;
use warnings;

view all matches for this distribution

Data-Partial-Google

2 results

lib/Data/Partial/Google.pm view on Meta::CPAN


   foo/bar/baz

will return the 'baz' property of the 'bar' property of the 'foo' property.

Arrays are handled transparently: if 'foo' is an array, then the rule
'bar/baz' will be applied to every entry in 'foo'.

=head2 Sub-selection

Use the parentheses to select specific properties from inside another:

view all matches for this distribution

Data-Password-Filter

1 match

share/dictionary.txt view on Meta::CPAN

transom's
transoms
transparencies
transparency
transparency's
transparent
transparently
transpiration
transpiration's
transpire
transpired
transpires

view all matches for this distribution

Data-Password-zxcvbn-French

1 match

lib/Data/Password/zxcvbn/RankedDictionaries/French.pm view on Meta::CPAN

    'transmutation' => 26753,
    'transnationale' => 27583,
    'transparait' => 22362,
    'transparaitre' => 25989,
    'transparence' => 8037,
    'transparent' => 10191,
    'transparente' => 13150,
    'transparentes' => 20275,
    'transparents' => 17947,
    'transperce' => 21025,
    'transpercer' => 29551,
    'transpiration' => 29552,
    'transplantation' => 16912,
    'transport' => 860,

view all matches for this distribution

Data-Password-zxcvbn-German

1 match

lib/Data/Password/zxcvbn/RankedDictionaries/German.pm view on Meta::CPAN

    'transformatoren' => 28740,
    'transformiert' => 28741,
    'transistoren' => 29702,
    'transit' => 15066,
    'transkription' => 23608,
    'transparent' => 11249,
    'transparente' => 20207,
    'transparenten' => 23026,
    'transparenz' => 10396,
    'transport' => 2809,
    'transportation' => 21077,
    'transporter' => 15699,
    'transportieren' => 6572,

view all matches for this distribution

Data-Password-zxcvbn

1 match

lib/Data/Password/zxcvbn/RankedDictionaries/English.pm view on Meta::CPAN

    'transgression' => 13456,
    'transgressions' => 17622,
    'transients' => 20065,
    'transitory' => 20064,
    'translate' => 4325,
    'transparent' => 5162,
    'transpired' => 13455,
    'transplant' => 2436,
    'transplants' => 15819,
    'transponder' => 12167,
    'transsexual' => 14495,

view all matches for this distribution

Data-Pulp

2 results

lib/Data/Pulp.pm view on Meta::CPAN

        nil { ... # Do action if value is undefined }
    ;

    $pulper->pulp( $value )

A pulper can act transparently on a single value, ARRAY, or HASH:

    my $set = $pulper->prepare( $value ) # A single value list
    my $set = $pulper->prepare( [ $value, ... ] )
    my $set = $pulper->prepare( { key => $value, ... } ) # Throws away the keys, basically

view all matches for this distribution

Data-Random-Contact

1 match

lib/Data/Random/Contact/Language/EN.pm view on Meta::CPAN

transom's
transoms
transparencies
transparency
transparency's
transparent
transparently
transpiration
transpiration's
transpire
transpired
transpires

view all matches for this distribution

Data-Random

1 match

lib/Data/Random/dict view on Meta::CPAN

nonterminal
nonterminals
nonterminating
nontermination
nonthermal
nontransparent
nontrivial
nonuniform
nonuniformity
nonzero
noodle

lib/Data/Random/dict view on Meta::CPAN

transmogrification
transmogrify
transpacific
transparencies
transparency
transparent
transparently
transpire
transpired
transpires
transpiring
transplant

view all matches for this distribution

Data-Rmap

1 match

lib/Data/Rmap.pm view on Meta::CPAN

        # Call the $code
        if($self->want & $type) {
            my $e; # local($@) and rethrow caused problems
            my @got;
            {
                local ($@); # don't trample, cut impl. should be transparent
                # call in array context.  pass block for reentrancy
                @got = eval { $self->call() };
                $e = $@;
            }

view all matches for this distribution

Data-Secs2

1 match

    }


    #########
    # References to arrays and scalars in the config may
    # be transparent.
    #
    my $current_value = $key_p->{$key};
    if( ref($current_value) eq 'SCALAR') {
        $current_value = $$current_value;
    }

 
The C<tech_config> subroutine always returns the
C<$old_value> of C<$dot_index> and only writes
the contents if C<$new_value> is defined.

The 'SCALAR' and 'ARRAY' references are transparent.
The C<tech_config> subroutine, when it senses that
the C<$dot_index> is for a 'SCALAR' and 'ARRAY' reference,
will read or write the contents instead of the reference.

The The C<tech_config> subroutine will read 'HASH" references

view all matches for this distribution

Data-SecsPack

1 match

    }


    #########
    # References to arrays and scalars in the config may
    # be transparent.
    #
    my $current_value = $key_p->{$key};
    if( ref($current_value) eq 'SCALAR') {
        $current_value = $$current_value;
    }

 
The C<tech_config> subroutine always returns the
C<$old_value> of C<$dot_index> and only writes
the contents if C<$new_value> is defined.

The 'SCALAR' and 'ARRAY' references are transparent.
The C<tech_config> subroutine, when it senses that
the C<$dot_index> is for a 'SCALAR' and 'ARRAY' reference,
will read or write the contents instead of the reference.

The The C<tech_config> subroutine will read 'HASH" references

view all matches for this distribution

Data-Show

1 match

lib/Data/Show.pm view on Meta::CPAN

        my %style        = %{ $STYLE[ $hints_ref->{'Data::Show/style'} ] };
        my $termwidth    = $hints_ref->{'Data::Show/termwidth'};

        # Warn about side-effects of multi-arg calls to show() in scalar context...
        if (defined $call_context && !$call_context && @_ > 1) {
            warn "Call to show() may not be not transparent at $file line $line\n";
        }

        # Serialize Contextual::Return objects (can break some dumpers in the Data::Dump family)...
        my @data = map { ref() =~ m{\AContextual::Return::Value}
                    ? do {my $v = $_->Contextual::Return::DUMP(); $v =~ s[\}\n][\},\n]gxms; eval $v; }

lib/Data/Show.pm view on Meta::CPAN

You would have also received one or more of the three preceding
diagnostics. Consult their entries for suggestions on silencing
this warning.


=item C<< Call to show() may not be not transparent >>

The call to C<show()> has been inserted into a scalar context,
but was passed two or more arguments to dump. This can change
the behaviour of the surrounding code. For example, consider
the following statements:

view all matches for this distribution

Data-StackedHash

1 match

lib/Data/StackedHash.pm view on Meta::CPAN



=head1 DESCRIPTION

The Data::StackedHash module implements a stack of hashes; the whole
stack acts collectively and transparently as a single PERL hash, that
is, you can perform the usual operations (fetching/storing values,
I<keys>, I<delete>, etc.)  on it.  All the PERL buitlins which operate
on hashes are supported.

Assigning a value to a key, as in C<< $h{'a'}=1 >>, puts the key/value

view all matches for this distribution

Data-Stag

1 match

scripts/stag-drawtree.pl view on Meta::CPAN


my $fgcol = $im->colorAllocate(0, 0, 0);
my $linecol = $im->colorAllocate(0, 0, 0);
my $namecol = $im->colorAllocate(0, 0, 0);
my $datacol = $im->colorAllocate(255, 0, 0);
#$im->transparent($bgcol);
$im->interlaced('true');


drawbox($im, $box);
if ($out) {

view all matches for this distribution

Data-Startup

1 match

    }


    #########
    # References to arrays and scalars in the config may
    # be transparent.
    #
    my $current_value = $key_p->{$key};
    if( ref($current_value) eq 'SCALAR') {
        $current_value = $$current_value;
    }