Free such a case software for linux

CLASS HIERARCHY

Hash::Case
is a Tie::StdHash
is a Tie::Hash

SYNOPSIS

use Hash::Case::Lower;
tie my(%lchash), Hash::Case::Lower;
$lchash{StraNGeKeY} = 3;
print keys %lchash; # strangekey

Hash::Case is the base class for various classes which tie special treatment for the casing of keys. Be aware of the differences in implementation: Lower and Upper are tied native hashes: these hashes have no need for hidden fields or other assisting data structured. A case Preserve hash will actually create three hashes.

The following strategies are implemented:

Hash::Case::Lower (native hash)

Keys are always considered lower case. The internals of this module translate any incoming key to lower case before it is used.

Hash::Case::Upper (native hash)

Like the ::Lower, but then all keys are always translated into upper case. This module can be of use for some databases, which do translate everything to capitals as well. To avoid confusion, you may want to have you own internal Perl hash do this as well.

Hash::Case::Preserve

The actual casing is ignored, but not forgotten.

METHODS

tie HASH, TIE, [VALUES,] OPTIONS

Tie the HASH with the TIE package which extends Hash::Case. The OPTIONS differ per implementation: read the manual page for the package you actually use. The VALUES is a reference to an array containing key-value pairs, or a reference to a hash: they fill the initial hash.

Examples:

my %x;
tie %x, Hash::Case::Lower;
$x{Upper} = 3;
print keys %x; # upper

my @y = (ABC => 3, DeF => 4);
tie %x, Hash::Case::Lower, @y;
print keys %x; # abc def

my %z = (ABC => 3, DeF => 4);
tie %x, Hash::Case::Lower, %z;
addPairs PAIRS

Specify an even length list of alternating key and value to be stored in the hash.

addHashData HASH

Add the data of a hash (passed as reference) to the created tied hash. The existing values in the hash remain, the keys are adapted to the needs of the the casing.

setHash HASH

The functionality differs for native and wrapper hashes. For native hashes, this is the same as first clearing the hash, and then a call to addHashData. Wrapper hashes will use the hash you specify here to store the data, and re-create the mapping hash.

Petals on a Rose is an intriguing puzzle game for all ages. This website claims that Bill Gates was stumped by it for two days. Its usually played with a group of friends and a set of 5 dice. The game master rolls the dice and tells everyone the answer. This computer version of the puzzle works similarly, only in this case the computer plays as the game master.

To play you just double click the icon to start the program. Type your guess in the "Answer" field and press "Check". If your guess is correct you get congratulated, otherwise you need to try again. If you get tired of guessing you can press the "Give Up" button and youll get the answer to that particular roll.

Just press the "Roll Dice" button at any time to get a new set of numbers.

Always remember, dont tell the answer to anyone!

Have fun, and good luck.

Sawdog (Simple Active Watch-DOG) is a suite of scripts that informs the system operators of mission critical servers in the case of a failure.

A set of small executables (i.e. expect scripts) are executed, and if one executable fails, it sends an email or an SMS to the sysop. There are 3 states known to sawdog: alive, unknown, and dead. Only certain state transitions trigger a notification.

On a Web interface, the states of all hosts are visible. So far, there are scripts to check for DNS, FTP, HTTP, HTTPS, ICMP, IMAP, MS SQL, MySQL, Notes, NTP, POP3, PostgreSQL, SMB, SMTP, SNMP, SSH, telnet, TWS, VNM, and Webmin.

Data::Locations - magic insertion points in your data
Did you already encounter the problem that you had to produce some data in a particular order, but that some piece of the data was still unavailable at the point in the sequence where it belonged and where it should have been produced?
Did you also have to resort to cumbersome and tedious measures such as storing the first and the last part of your data separately, then producing the missing middle part, and finally putting it all together?
In this simple case, involving only one deferred insertion, you might still put up with this solution.
But if there is more than one deferred insertion, requiring the handling of many fragments of data, you will probably get annoyed and frustrated.
You might even have to struggle with limitations of the file system of your operating system, or handling so many files might considerably slow down your application due to excessive file input/output.
And if you dont know exactly beforehand how many deferred insertions there will be (if this depends dynamically on the data being processed), and/or if the pieces of data you need to insert need additional (nested) insertions themselves, things will get really tricky, messy and troublesome.
In such a case you might wonder if there wasnt an elegant solution to this problem.
This is where the "Data::Locations" module comes in: It handles such insertion points automatically for you, no matter how many and how deeply nested, purely in memory, requiring no (inherently slower) file input/output operations.
(The underlying operating system will automatically take care if the amount of data becomes too large to be handled fully in memory, though, by swapping out unneeded parts.)
Moreover, it also allows you to insert the same fragment of data into SEVERAL different places.
This increases space efficiency because the same data is stored in memory only once, but used multiple times.
Potential infinite recursion loops are detected automatically and refused.
In order to better understand the underlying concept, think of "Data::Locations" as virtual files with almost random access: You can write data to them, you can say "reserve some space here which I will fill in later", and continue writing data.
And you can of course also read from these virtual files, at any time, in order to see the data that a given virtual file currently contains.
When you are finished filling in all the different parts of your virtual file, you can write out its contents in flattened form to a physical, real file this time, or process it otherwise (purely in memory, if you wish).
You can also think of "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 bubbles 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.
Enhancements:
- Fixed test file "02___refcount.t" to auto-adjust the offset dealing with self-ties not incrementing
- the refcount in some Perl versions.
- Added a warning to "Makefile.PL" that Perl versions including and between v5.6.1 and v5.7.0 are not fully supported (test file "11_______dump.t" dumps core).

Legal Case Management System is a software aimed for use by not-for-profit legal advice centres in order to make better follow-ups of their cases, including client consultations and court events.
Integration into your offices activities
The software can be installed either on one computer or shared over a network. You can then provide a personal access to each member of your organisation. This allows them to chose how they want to work on a case and how the case information should be shared with the other members.
Users can then create new cases (or campaigns) to which they can attach a list of people or organisations involved as well as to add follow-up information.
- Organisations providing advice or consultations will benefit from being able to quickly consult the database for background information on a clients case and evolution, contact information, etc.
- Lawyers can use the software to track the evolution of a case and the resources spent on a particular client, as well as to track the status of a case in court.
- Office managers can generate reports based on the activity for a given period. The variety of reports include: activity overview for each staff members, statistical information on cases or clients, and general overview on how the usage of the organisations resources. Such reports facilitate the reporting on projects and the creation of new budgets.
Software freedom
LCM is a Bulgarian community initiative developed by IRBF, funded by the Open Society Institute and distributed as "free software". The software is being developed for local not-for-profit advice centers, but anyone has the freedom to use it, to redistribute it locally and to adapt it to their own needs.
The software is currently available in English and Bulgarian, but more translations are welcomed and very easy to do with the help of an online translation interface.
Enhancements:
- This release fixes the "sum billed" format error (if the field is active), as well as the "case notes" being lost after edit.