Free to wrap software for linux

MySQL wrapped is a C++ wrapper for the MySQL database C application programming interface.
Examples:
The following example should be linked with the mysqlclient library from the MySQL distribution / build.
#include
#include
#include
#include
#include "Database.h"
#include "Query.h"
int main()
{
Database db("localhost","dbuser","","testdb");
Query q(db);
q.execute("delete from user");
q.execute("insert into user values(1,First Person)");
q.execute("insert into user values(2,Another Person)");
q.get_result("select num,name from user");
while (q.fetch_row())
{
long num = q.getval();
std::string name = q.getstr();
printf("User#%ld: %sn", num, name.c_str() );
}
q.free_result();
}
Enhancements:
- This release adds methods to access fields by name.

MR Tech Link Wrapper Lite is a Firefox extension that wraps long links and lines to spare you from having to scroll left and right.

Hidden preferences:

- length to wrap: link_wrapper.wrapLength, default value is "15"
- Sites to ignore: link_wrapper.ignoreList, default regex value is "google.com|mail.yahoo.com|hushmail.com|blog.myspace.com|webmail.aol.com"
- html tags to ignore: link_wrapper.ignoreTags, default regex value includes tons of tags
- Enable page character limit to improve performance on large pages: link_wrapper.charLimitEnabled, default value is false
- If enabled use this character limit: link_wrapper.charLimit, default value is 30000

If Link Wrapper doesnt appear to work for you can:

- some blog site will break with this extension just add the domain to the "Sites to ignore" list in the options
- bump the limit of character to something higher than 30000 in the options dialog
- if you experience slow downs on large pages, enabling the character limit in the options dialog.

Note: Link Wrapper will force Linkification to only highlight part of a text link, version 1.2.2 and newer of Linkification adds a "Thorough Mode" which is disabled by default, enabling it will resolve this, or you can just double-click on the unhighlighted text on the right of the text from a link to have it open properly.

CGI::Wrap is a buffer output when building CGI programs.

SYNOPSIS

use CGI;
use CGI::Croak;
use CGI::Wrap;

$query = new CGI;
savequery $query; # to reconstruct input
$CGI::Out::mailto = fred; # override default of $<

run &myfunc, @myargs # a function
run sub { code } # an inline function
run code # something to eval

sub myfunc {
out $query->header();
out $query->start_html(
-title=>A test,
-author=>muir@idiom.com);
}
$CGI::Out::out # is the buffer

This is a helper routine for building CGI programs. It buffers stdout until youre completed building your output. If you should get an error before you are finished, then it will display a nice error message (in HTML), log the error, and send email about the problem.

To use it, you must condense your program down to a single function call and then use CGI::Wrap::run to call it.

Instead of print, use out.

Zerotools project contains a set of tools to aid keeping virtual disks clean (by filling binary zero to those regions which are no longer in "use"). This is done on-the-fly or manually, depending on which tool suits the needs best.

In technical terms the on-the-fly mechanism uses LD_PRELOAD to wrap the unlink library call and zerounlink-wrapper provides a symlink based mechanism to target individual programs so that they will be run using the unlink wrapper. For comparison against other tools, please see the "Other solutions" section.

Please note that zerotools dont compete with various tools that rewrite file contents with "random" data in order to make data retrieval close to impossible. Do not use zerotools for this, or claim that they are good tools for this. Theyre not. (This text was added for people who only read introductions.)

Zerotools are Linux specific, implemented using C and licensed under GNU General Public License (v2). The tools are provided without a warranty of any kind, in the understanding that software bugs do exist and bad things can happen.

Bugs and limitations

There are no known bugs. Known to me at least. Bugs will be fixed based on intelligent reporting by end users or automatically if I have extra time. My email address is at the start of each source file should you feel the need to send patches.
Thread-protection is not yet tested properly. Neither is LFS-requirement (which means that zerotools might not be able to handle files over 2 GiB size on 32-bit architectures). Building or running zerotools on older Linux systems has not been attempted (but will be done as soon as older systems are installed in test environment). User participation in testing is also appreciated.

Testing has been done on many Linux distributions running kernels (2.4 and 2.6) and with glibc versions (2.3.2 to 2.5.3, with vendor patches, so this is advisory information only). Architectures that were tested are x86, x86_64, ia_64, and ppc (32-bit). Other architecture test results are welcome.

zerounlink and zerounlink-wrapper do not work with statically linked executables. This is a limitation in the technique and there are no workarounds (known to me).
One mis-feature exists in zerounlink: when checking whether a file should be zeroed or not, zerounlink doesnt take into account sparse files. If the file is sparse, it would make sense to overwrite only the parts of file which have non-zero content.

This means that zerounlink would have to read through all of the original file and search for the non-zero content first. This would also mean that instead of only writing to the unlinked file, zerounlink would have to read it in as well. This would cause extra I/O operations. Not sure whether special sparse-file support is worth the extra effort and complexity so this feature has not been implemented.

Drop me a note if you think you need it. (The reason for having this feature is to do with how most dynamic virtual disks are implemented. They will allocate real space when any data is written to an vdisk area, even if the writes consist of only binary zeroes. Its a bit silly, but thats how most of them work. This is the same reason why filling the filesystem with a file containing only binary zeroes (with dd or other tool) is not really a good solution to clean up the vdisk.)

When reporting bugs about listings on this web page, please include the listing number and line number of the problematic bit to speed up fixes. For other web-related fixes, try to include two to three word phrase which can be grepped with. Do not send diffs against xhtml.

POE::Component::SubWrapper is an event based wrapper for subs.
SYNOPSIS
use POE::Component::SubWrapper;
POE::Component::SubWrapper->spawn(main);
$kernel->post(main, my_sub, [ $arg1, $arg2, $arg3 ], callback_state);
This is a module which provides an event based wrapper for subroutines.
SubWrapper components are not normal objects, but are instead spawned as separate sessions. This is done with with PoCo::SubWrappers spawn method, which takes one required and one optional argument. The first argument is the package name to wrap. This is required. The second argument is optional and contains an alias to give to the session created. If no alias is supplied, the package name is used as an alias.
Another way to create SubWrapper components is to use the poeize method, which is included in the default export list of the package. You can simply do:
poeize Data::Dumper;
and Data::Dumper will be wrapped into a session with the alias Data::Dumper.
When a SubWrapper component is created, it scans the package named for subroutines, and creates one state in the session created with the same name of the subroutine.
The states each accept 3 arguments:
- An arrayref to a list of arguments to give the subroutine.
- A state to callback with the results.
- A string, either SCALAR, or ARRAY, allowing you to decide which context the function handled by this state will be called in.
The states all call the function with the name matching the state, and give it the supplied arguments. They then postback the results to the named callback state. The results are contained in ARG0 and are either a scalar if the function was called in scalar context, or an arrayref of results if the function was called in list context.

Term::Prompt is a Perl extension for prompting a user for information.

SYNOPSIS

use Term::Prompt;
$value = &prompt(...);

use Term::Prompt qw(termwrap);
print &termwrap(...);

$Term::Prompt::MULTILINE_INDENT = ;

PREREQUISITES

You must have Text::Wrap and Term::ReadKey available on your system.

This main function of this module is to accept interactive input. You specify the type of inputs allowed, a prompt, help text and defaults and it will deal with the user interface, (and the user!), by displaying the prompt, showing the default, and checking to be sure that the response is one of the legal choices. Additional "types" that could be added would be a phone type, a social security type, a generic numeric pattern type...

Neon++ is a C++ wrapper library for libneon (http://webdav.org/neon). Neon++ aims to wrap the entire neon library into several convenient and simple-to-use C++ classes.
Enhancements:
- The basic API is wrapped: requests with or without reading response bodies can be made, using either the GET or POST method.
- Stream operators to stream text data directly to e.g. stringstreams or files are available, as well as convenient methods to retrieve binary data (images, etc.).
- Sample applications are included.