Zen

Translation

English leap/perl-Image-ExifTool/summary
Read and write meta information
40/310 · 31

Sign in to save the translation.

English Polish Actions
IO::stringy Perl module
Nie znaleziono nowych modułów
Fast Lookup of Country Codes From Ip Addresses
 
Finding the home country of a client using only the IP address can be difficult. Looking up the domain name associated with that address can provide some help, but many IP address are not reverse mapped to any useful domain, and the most common domain (.com) offers no help when looking for country.

This module comes bundled with a database of countries where various IP addresses have been assigned. Although the country of assignment will probably be the country associated with a large ISP rather than the client herself, this is probably good enough for most log analysis applications, and under test has proved to be as accurate as reverse-DNS and WHOIS lookup.
 
System() and background procs w/ piping, redirs, ptys (Unix, Win32)
 
IPC::Run allows you to run and interact with child processes using files, pipes, and pseudo-ttys. Both system()-style and scripted usages are supported and may be mixed. Likewise, functional and OO API styles are both supported and may be mixed.

Various redirection operators reminiscent of those seen on common Unix and DOS command lines are provided.
 
Run a Subprocess with Input/Ouput Redirection
 
This module allows you to run a subprocess and redirect stdin, stdout, and/or stderr to files and perl data structures. It aims to satisfy 99% of the need for using 'system', 'qx', and 'open3' with a simple, extremely Perlish API.

Speed, simplicity, and portability are paramount. (That's speed of Perl code; which is often much slower than the kind of buffered I/O that this module uses to spool input to and output from the child command.)
 
Lightweight interface to shared memory
 
IPC::ShareLite provides a simple interface to shared memory, allowing data to be efficiently communicated between processes. Your operating system must support SysV IPC (shared memory and semaphores) in order to use this module.

IPC::ShareLite provides an abstraction of the shared memory and semaphore facilities of SysV IPC, allowing the storage of arbitrarily large data; the module automatically acquires and removes shared memory segments as needed. Storage and retrieval of data is atomic, and locking functions are provided for higher-level synchronization.

In many respects, this module is similar to IPC::Shareable. However, IPC::ShareLite does not provide a tied interface, does not (automatically) allow the storage of variables, and is written in C for additional speed.

Construct an IPC::ShareLite object by calling its constructor:

my $share = IPC::ShareLite->new( -key => 1971, -create => 'yes', -destroy => 'no' ) or die $!;

Once an instance has been created, data can be written to shared memory by calling the store() method:

$share->store("This is going in shared memory");

Retrieve the data by calling the fetch() method:

my $str = $share->fetch();

The store() and fetch() methods are atomic; any processes attempting to read or write to the memory are blocked until these calls finish. However, in certain situations, you'll want to perform multiple operations atomically. Advisory locking methods are available for this purpose.

An exclusive lock is obtained by calling the lock() method:

$share->lock();

Happily, the lock() method also accepts all of the flags recognized by the flock() system call. So, for example, you can obtain a shared lock like this:

$share->lock( LOCK_SH );

Or, you can make either type of lock non-blocking:

$share->lock( LOCK_EX|LOCK_NB );

Release the lock by calling the unlock() method:

$share->unlock;
 
Run commands simply, with detailed diagnostics
 
Calling Perl's in-built 'system()' function is easy, determining if it was successful is _hard_. Let's face it, '$?' isn't the nicest variable in the world to play with, and even if you _do_ check it, producing a well-formatted error string takes a lot of work.

'IPC::System::Simple' takes the hard work out of calling external commands. In fact, if you want to be really lazy, you can just write:

use IPC::System::Simple qw(system);

and all of your 'system' commands will either succeed (run to completion and return a zero exit value), or die with rich diagnostic messages.

The 'IPC::System::Simple' module also provides a simple replacement to Perl's backticks operator. Simply write:

use IPC::System::Simple qw(capture);

and then use the the /capture() manpage command just like you'd use backticks. If there's an error, it will die with a detailed description of what went wrong. Better still, you can even use 'capturex()' to run the equivalent of backticks, but without the shell:

use IPC::System::Simple qw(capturex);

my $result = capturex($command, @args);

If you want more power than the basic interface, including the ability to specify which exit values are acceptable, trap errors, or process diagnostics, then read on!
 
Internationalized Resource Identifiers
Instalacja albo aktualizacja
The IRI module provides an object representation for Internationalized Resource Identifiers (IRIs) as defined by at http://www.ietf.org/rfc/rfc3987.txt and supports their parsing, serializing, and base resolution.
 
Database connection caching and organization
 
Ima::DBI attempts to organize and facilitate caching and more efficient use of database connections and statement handles by storing DBI and SQL information with your class (instead of as seperate objects). This allows you to pass around just one object without worrying about a trail of DBI handles behind it.

One of the things I always found annoying about writing large programs with DBI was making sure that I didn't have duplicate database handles open. I was also annoyed by the somewhat wasteful nature of the prepare/execute/finish route I'd tend to go through in my subroutines. The new DBI->connect_cached and DBI->prepare_cached helped a lot, but I still had to throw around global datasource, username and password information.

So, after a while I grew a small library of DBI helper routines and techniques. Ima::DBI is the culmination of all this, put into a nice(?), clean(?) class to be inherited from.
 
Read and write meta information
Przetwarzanie plików konfiguracyjnych...
Reads and writes meta information in a wide variety of files, including the maker notes of many digital cameras by various manufacturers such as Canon, Casio, DJI, FLIR, FujiFilm, GE, GoPro, HP, JVC/Victor, Kodak, Leaf, Minolta/Konica-Minolta, Nikon, Nintendo, Olympus/Epson, Panasonic/Leica, Pentax/Asahi, Phase One, Reconyx, Ricoh, Samsung, Sanyo, Sigma/Foveon and Sony.
 
Extract meta information from image files
 
This module provides functions to extract various kinds of meta information from image files.
 
Perl extension for the SANE (Scanner Access Now Easy)
 
These Perl bindings for the SANE (Scanner Access Now Easy) Project allow you to access SANE-compatible scanners in a Perlish and object-oriented way, freeing you from the casting and memory management in C, yet remaining very close in spirit to original API.

Find out more about SANE at http://www.sane-project.org.
 
Read the dimensions of an image in several popular formats
 
The *Image::Size* library is based upon the 'wwwis' script written by Alex Knowles _(alex@ed.ac.uk)_, a tool to examine HTML and add 'width' and 'height' parameters to image tags. The sizes are cached internally based on file name, so multiple calls on the same file name (such as images used in bulleted lists, for example) do not result in repeated computations.
 
Import packages into other packages
 
Writing exporters is a pain. Some use the Exporter manpage, some use the Sub::Exporter manpage, some use the Moose::Exporter manpage, some use the Exporter::Declare manpage ... and some things are pragmas.

Exporting on someone else's behalf is harder. The exporters don't provide a consistent API for this, and pragmas need to have their import method called directly, since they effect the current unit of compilation.

'Import::Into' provides global methods to make this painless.
 
Alternative but compatible interface to modules that export symbols
 
This module acts as a layer between Exporter and modules which consume exports. It is feature-compatible with Exporter, plus some much needed extras. You can use this to import symbols from any exporter that follows Exporters specification. The exporter modules themselves do not need to use or inherit from the Exporter module, they just need to set '@EXPORT' and/or other variables.
 
Write Perl Subroutines in Other Programming Languages
 
The Inline module allows you to put source code from other programming languages directly "inline" in a Perl script or module. The code is automatically compiled as needed, and then loaded for immediate access from Perl.

Inline saves you from the hassle of having to write and compile your own glue code using facilities like XS or SWIG. Simply type the code where you want it and run your Perl as normal. All the hairy details are handled for you. The compilation and installation of your code chunks all happen transparently; all you will notice is the delay of compilation on the first run.

The Inline code only gets compiled the first time you run it (or whenever it is modified) so you only take the performance hit once. Code that is Inlined into distributed modules (like on the CPAN) will get compiled when the module is installed, so the end user will never notice the compilation time.

Best of all, it works the same on both Unix and Microsoft Windows. See Inline- Support for support information.
 
Write Perl subs and classes in Python
 
The 'Inline::Python' module allows you to put Python source code directly "inline" in a Perl script or module. It sets up an in-process Python interpreter, runs your code, and then examines Python's symbol table for things to bind to Perl. The process of interrogating the Python interpreter for globals only occurs the first time you run your Python code. The namespace is cached, and subsequent calls use the cached version.

This document describes 'Inline::Python', the Perl package which gives you access to a Python interpreter. For lack of a better place to keep it, it also gives you instructions on how to use 'perlmodule', the Python package which gives you access to the Perl interpreter.
 

Loading…

No matching activity found.
Browse all string changes

Things to check

Mismatched full stop

Source and translation do not both end with a full stop

Reset

Glossary

English Polish
No related strings found in the glossary.

String information

Source string description
leap/perl-Image-ExifTool/summary
String age
2 years ago
Last updated
2 weeks ago
Source string age
2 years ago
Translation file
pl/po/perl.pl.po, string 1021