view release on metacpan or  search on metacpan

lib/FFI/Platypus/Type/GoString.pm  view on Meta::CPAN

 $ffi->load_custom_type('::GoString' => 'gostring');
 $ffi->function( some_go_function => [ 'gostring' ] )->call("hello there!");

=head1 DESCRIPTION

This Platypus custom types lets you pass strings transparently into Go code
without having to create/pass L<FFI::Go::String> types manually.  Under the
covers L<FFI::Go::String> is used.

The Go language plugin L<FFI::Platypus::Lang::Go> will load this custom type
automatically, so probably best to just do this:

 view release on metacpan or  search on metacpan

deps/hidapi/doxygen/Doxyfile  view on Meta::CPAN

# This tag requires that the tag GENERATE_HTML is set to YES.

FORMULA_FONTSIZE       = 10

# Use the FORMULA_TRANSPARENT tag to determine whether or not the images
# generated for formulas are transparent PNGs. Transparent PNGs are not
# supported properly for IE 6.0, but are supported on all modern browsers.
#
# Note that when changing this option you need to delete any form_*.png files in
# the HTML output directory before the changes have effect.
# The default value is: YES.

deps/hidapi/doxygen/Doxyfile  view on Meta::CPAN

# Minimum value: 0, maximum value: 1000, default value: 0.
# This tag requires that the tag HAVE_DOT is set to YES.

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

 view release on metacpan or  search on metacpan

lib/Faker/Plugin/EnUs/JargonAdjective.pm  view on Meta::CPAN

    'out-of-the-box',
    'enterprise',
    'integrated',
    'impactful',
    'wireless',
    'transparent',
    'next-generation',
    'cutting-edge',
    'user-centric',
    'visionary',
    'customized',

 view release on metacpan or  search on metacpan

lib/Farabi/files/public/assets/bootstrap/css/bootstrap.min.css  view on Meta::CPAN

 * Copyright 2012 Twitter, Inc
 * Licensed under the Apache License v2.0
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Designed and built with all the love in the world @twitter by @mdo and @fat.
 */.clearfix{*zoom:1}.clearfix:before,.clearfix:after{display:table;line-height:0;content:""}.clearfix:after{clear:both}.hide-text{font:0/0 a;color:transparent;text-shadow:none;background-color:transparent;border:0}.input-block-level{display:block;wi...

 view release on metacpan or  search on metacpan

FigAnim.pm  view on Meta::CPAN

    $self->{justification} = undef;
    $self->{units} = undef;
    $self->{papersize} = undef;
    $self->{magnification} = undef;
    $self->{multiple_page} = undef;
    $self->{transparent_color} = undef;
    $self->{resolution} = undef;
    $self->{coord_system} = undef;
    
    # array containing the Color objects
    $self->{colors} = [];

FigAnim.pm  view on Meta::CPAN

sub clone {
    my $self = shift;
    my $obj = new FigAnim;
    
    foreach ('title','version','orientation','justification','units',
	     'papersize','magnification','multiple_page','transparent_color',
	     'resolution','coord_system','arcs','compounds','ellipses',
	     'polylines','splines','texts') {
	$obj->{$_} = $self->{$_};
    }
    

FigAnim.pm  view on Meta::CPAN

    $self->{justification} = nextline($fh);
    $self->{units} = nextline($fh);
    $self->{papersize} = nextline($fh);
    $self->{magnification} = nextline($fh);
    $self->{multiple_page} = nextline($fh);
    $self->{transparent_color} = nextline($fh);
    while (($line = nextline($fh)) =~ /^\# /) {
	$line =~ s/\# //;
	$self->{title} .= $line . "\n";
    }
    ($self->{resolution}, $self->{coord_system}) = split / /, $line;

FigAnim.pm  view on Meta::CPAN

    printf $fh "%s\n", $self->{justification};
    printf $fh "%s\n", $self->{units};
    printf $fh "%s\n", $self->{papersize};
    printf $fh "%.2f\n", $self->{magnification};
    printf $fh "%s\n", $self->{multiple_page};
    printf $fh "%d\n", $self->{transparent_color};
    if ($self->{title} ne "") {
	foreach (split(/\n/, $self->{title})) {
	    printf $fh "# $_\n";
	}
    }

 view release on metacpan or  search on metacpan

t/File/Test/Tech.pm  view on Meta::CPAN

   }


   #########
   # 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;
   }

t/File/Test/Tech.pm  view on Meta::CPAN

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

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

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

 view release on metacpan or  search on metacpan

lib/Simple.pm  view on Meta::CPAN

B<(caveat)>
When applied I<$options{location}> will be expanded to be absolute
(as required by APT method API).
However, that expansion is performed with each B<request()>
and, as mentioned above, transparently.
Thus if *you* set I<$options{location}> to non-absolute dirname,
than B<request()> once,
then *your* script changes CWD,
then B<request()> again,
then those B<request()>s will put results in two different dirctories.

 view release on metacpan or  search on metacpan

Changes  view on Meta::CPAN

	  - rework priority system
	  - make "applicable" apply to individual files, not entire 
	    installations
 	Attributes
	  - use all "applicable" plugins for reading and deleting,
	    allowing transparent upgrade to new attribute plugins

0.01    2 July 2006
        First version, released on an unsuspecting world.

 view release on metacpan or  search on metacpan

lib/File/Cache/Persistent.pm  view on Meta::CPAN

This module aims to put caching logic to the background and avoid manually
checking conditions of cache expiration. It also is useful when files are not
available after cache timeout and provides cached version although it is
inevitably outdated.

Access to the data is granted through C<get> method. It transparently reads the
file and caches it if it is needed. By default, raw content of the file is
put to the cache. 

=head2 new

 view release on metacpan or  search on metacpan

lib/File/DigestStore.pm  view on Meta::CPAN

The PerlIO layer to use when storing and retrieving data. Note that while
this could be used to set the encoding for string I/O (e.g. with
store_string()), the Digest algorithms expect your strings to be sequences
of octets. This is mainly here for if you wish to use a layer that performs
transparent compression.

=head1 PRIVATE MOOSE FIELDS

=head2 nhash (optional, builds an Algorithm::Nhash based on I<levels>)

 view release on metacpan or  search on metacpan

t/File/Test/Tech.pm  view on Meta::CPAN

    }


    #########
    # 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;
    }

t/File/Test/Tech.pm  view on Meta::CPAN

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

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

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

 view release on metacpan or  search on metacpan

lib/File/Fetch.pm  view on Meta::CPAN

which case the 'share' property will be defined. Additionally, volume
specifications that use '|' as ':' will be converted on read to use ':'.

On VMS, which has a volume concept, this field will be empty because VMS
file specifications are converted to absolute UNIX format and the volume
information is transparently included.

=item $ff->share

On systems with the concept of a network share (currently only Windows) returns
the sharename from a file://// url.  On other operating systems returns empty.

 view release on metacpan or  search on metacpan

META.yml  view on Meta::CPAN

---
abstract: 'open, read and seek into remote files and directories transparently'
author:
  - 'Thomas Drugeon, <tdrugeon@cpan.org>'
build_requires:
  ExtUtils::MakeMaker: 6.36
  Test::More: 0.42

 view release on metacpan or  search on metacpan

lib/File/KeePass/KDBX.pm  view on Meta::CPAN

some amount of interaction with unblessed data structures. Some effort was made to at least hide the magic
where reasonable; any magical behavior is incidental and not considered a feature.

You should expect some considerable overhead which makes this module generally slower than using either
B<File::KeePass> or B<File::KDBX> directly. In some cases this might be due to an inefficient implementation
in the shim, but largely it is the cost of transparent compatibility.

If performance is critical and you still don't want to rewrite your code to use B<File::KDBX> directly but do
want to take advantage of some of the new stuff, there is also the option to go part way. The strategy here is
to use B<File::KeePass::KDBX> to load a database and then immediately convert it to a B<File::KeePass> object.
Use that object without any runtime overhead, and then if and when you're ready to save the database or use

 view release on metacpan or  search on metacpan

lib/File/LoadLines.pm  view on Meta::CPAN

File::LoadLines provides an easy way to load the contents of a text
file into an array of lines. It is intended for small to moderate size files
like config files that are often produced by weird tools (and users).

It will transparently fetch data from the network if the provided file
name is a URL.

File::LoadLines automatically handles ASCII, Latin-1 and UTF-8 text.
When the file has a BOM, it handles UTF-8, UTF-16 LE and BE, and
UTF-32 LE and BE.

lib/File/LoadLines.pm  view on Meta::CPAN

There are currently no other modules that handle BOM detection and
line splitting.

I have a faint hope that future versions of Perl and Raku will deal
with this transparently, but I fear the worst.

=head1 HINTS

When you have raw file data (e.g. from a zip), you can use loadlines()
to decode and unpack:

    open( my $data, '<', \$contents );
    $lines = loadlines( $data, $options );

There is no hard requirement on LWP. If you want to use transparent
fetching of data over the network please make sure LWP::UserAgent is
available.

=head1 AUTHOR

 view release on metacpan or  search on metacpan

lib/File/Locate/Iterator.pm  view on Meta::CPAN

If you have the recommended C<File::Map> module then iterators share an
C<mmap()> of the database file.  Otherwise the database file is a separate
open handle in each iterator, meaning a file descriptor and PerlIO buffering
each.  Sharing a handle and having each seek to its desired position would
be possible, but a seek drops buffered data so would be slower.  Maybe some
hairy C<PerlIO> or C<IO::Handle> trickery could transparently share an fd
and keep buffered blocks from multiple file positions.

=head1 SEE ALSO

L<Iterator::Locate>, L<Iterator::Simple::Locate>,

 view release on metacpan or  search on metacpan

t/File/Test/Tech.pm  view on Meta::CPAN

    }


    #########
    # 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;
    }

t/File/Test/Tech.pm  view on Meta::CPAN

 
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 release on metacpan or  search on metacpan

lib/File/MimeInfo/Magic.pm  view on Meta::CPAN

    use File::MimeInfo::Magic;
    my $mime_type = mimetype($file);

=head1 DESCRIPTION

This module inherits from L<File::MimeInfo>, it is transparent
to its functions but adds support for the freedesktop magic file.

Magic data is hashed when you need it for the first time.
If you want to force hashing earlier use the C<rehash()> function.

 view release on metacpan or  search on metacpan

t/File/Test/Tech.pm  view on Meta::CPAN

   }


   #########
   # 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;
   }

t/File/Test/Tech.pm  view on Meta::CPAN

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

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

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

 view release on metacpan or  search on metacpan

t/File/Test/Tech.pm  view on Meta::CPAN

    }


    #########
    # 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;
    }

t/File/Test/Tech.pm  view on Meta::CPAN

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

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

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

 view release on metacpan or  search on metacpan

Remote.pm  view on Meta::CPAN

__END__ DATA

=head1 NAME

File::Remote - Read/write/edit remote files transparently

=head1 SYNOPSIS

   #
   # Two ways to use File::Remote

Remote.pm  view on Meta::CPAN

C<File::Remote> uses rsh/rcp (or ssh/scp, depending on how you configure it)
to edit the file remotely.  Otherwise, it assumes the file is local and
passes calls directly through to Perl's core functions.

The nice thing about this module is that you can use it for I<all> your
file calls, since it handles both remote and local files transparently.
This means you don't have to put a whole bunch of checks for remote files
in your code.  Plus, if you use the function-oriented interface along with
the C<:replace> tag, you can actually redefine the Perl builtin file
functions. This means that your existing Perl scripts can automatically
handle remote files with no re-engineering(!).

Remote.pm  view on Meta::CPAN

   chown("root", "other", "/local/new/dir");
   unlink("host:/remote/file");

This is pretty neat; since C<File::Remote> will pass calls to local files
straight through to Perl's core functions, you'll be able to do all this
"transparently" and not care about the locations of the files. Plus,
this has the big advantage of making your existing Perl scripts capable
of dealing with remote files without having to rewrite any code.

Because the names for the C<File::Remote> methods clash with the Perl builtins,
if you use the function-oriented style with the C<:standard> tag there is

 view release on metacpan or  search on metacpan

t/File/Test/Tech.pm  view on Meta::CPAN

    }


    #########
    # 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;
    }

t/File/Test/Tech.pm  view on Meta::CPAN

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

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

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

 view release on metacpan or  search on metacpan

script/rsybak  view on Meta::CPAN

#funny/weird/dumb stuff).
#
#This is useful when you want to do the encoding yourself (e.g. when you
#want to have UTF-16 encoded JSON texts) or when some other layer does
#the encoding for you (for example, when printing to a terminal using a
#filehandle that transparently encodes to UTF-8 you certainly do NOT want
#to UTF-8 encode your data first and have Perl encode it another time).
#
#=item C<utf8> flag enabled
#
#If the C<utf8>-flag is enabled, C<encode>/C<decode> will encode all

 view release on metacpan or  search on metacpan

Todo  view on Meta::CPAN

	action and G/GW/GWILLIAMS/RDF-Query-2.100_01.tar.gz the first after it

2009-03-15  Andreas J. Koenig  <andk@cpan.org>

	* currently recent_events has the side effect of setting dirtymark
	because it forces a read on the file. That should be transparent, so
	that the dirtymark call always forces a cache-able(?) read.

	* The bug below is -- after a lot of trying -- not reproducible on a
	small script, only in the large test script. The closest to the output
	below was:

 view release on metacpan or  search on metacpan

lib/File/ShareDir/Tarball.pm  view on Meta::CPAN

  $File::ShareDir::Tarball::AUTHORITY = 'cpan:YANICK';
}
{
  $File::ShareDir::Tarball::VERSION = '0.2.2';
}
# ABSTRACT: Deal transparently with shared files distributed as tarballs


use strict;
use warnings;

lib/File/ShareDir/Tarball.pm  view on Meta::CPAN

=pod

=head1 NAME

File::ShareDir::Tarball - Deal transparently with shared files distributed as tarballs

=head1 VERSION

version 0.2.2

 view release on metacpan or  search on metacpan

t/File/Test/Tech.pm  view on Meta::CPAN

    }


    #########
    # 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;
    }

t/File/Test/Tech.pm  view on Meta::CPAN

 
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 release on metacpan or  search on metacpan

t/File/Test/Tech.pm  view on Meta::CPAN

    }


    #########
    # 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;
    }

t/File/Test/Tech.pm  view on Meta::CPAN

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

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

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

 view release on metacpan or  search on metacpan

README  view on Meta::CPAN

The module tries hard not to busy wait on the file, dynamicaly calcultaing 
how long it should wait before it pays to try reading the file again.

The module should handle normal log truncations ("close; move; open"
or "cat /dev/null >file") transparently, without losing any input.

Currently this package requires Time::HiRes, because it often needs to sleep
for less than one second. (I don't beleive one should busy wait on a file
just because it gets more than one line/second).

 view release on metacpan or  search on metacpan

lib/File/UStore.pm  view on Meta::CPAN

=head1 USE CASE FOR THIS MODULE IN LIEU OF A HASH BASED STORAGE

File::HStore is a similar module that
provides File Hash based storage. However due to the nature of File
Hashing, File::HStore doesn't allow duplicates. If the same file is
stored a second time using File::HStore it transparently returns the
same hash it had returned last time as an id without adding any new 
file in storage due to inherent character of hash based storage, while 
this is useful if a user doesn't want any duplicates occurring in a
storage, this apparently trivial difference is risky in the use case
where two processes upload a duplicate file to the store and both

 view release on metacpan or  search on metacpan

Changes  view on Meta::CPAN

   additional set of tests in an automated "empty subclass test" of the
   modules native methods and all those it inherits from its ancestral
   classes.

 - More flock() related tweaking in private methods that implement
   File::Util's automatic, transparent file locking mechanism.

3.13_3 2002-11-13
 - Slightly optimized recursive directory listing features of package method
   File::Util::list_dir() and moved less-used method File::Util::load_dir()
   to AUTOLOAD.