Free history of libraries software for linux

This class can be used to keep track of the pages navigated by a user, so it can generate back or next links providing a similar effect to the use of the Javascript history.go() function.
It uses sessions to store an array variable that holds the URL of each page of a site that the user accesses. It can limit the number of pages that are kept in the history array.
It may also ignore pages accessed with the POST method or with certain URLs based on options that define exclusion regular expressions. The class can generate links to go back to the last page or the first page that was recorded.
Enhancements:
- The class is completely changed.
- This release adds creation of several objects of a class, a predefined start page, an expanded list of exceptions, and the methods get_history_back, get_history_next, is_history_back (check back one page), is_history_next (check the next page), get_history_backs (go to the first page), get_history_nexts (go to the last page), and get_history_header (go to the previous and next pages using external parameters).
- It adds history "always", and has more compatibility with javascript:history.go() (no checking previous and next pages).
- New methods have been added for the manipulation of history "always".

POCO C++ Libraries project are the next generation C++ class libraries for network-centric applications.

POCO, the C++ Portable Components, is a collection of open source C++ class libraries that simplify and accelerate the development of network-centric, portable applications in C++. The libraries integrate perfectly with the C++ Standard Library and fill many of the functional gaps left open by it.

Their modular and efficient design and implementation makes the C++ Portable Components extremely well suited for embedded development, an area where the C++ programming language is becoming increasingly popular, due to its suitability for both low-level (device I/O, interrupt handlers, etc.) and high-level object-oriented development. Of course, POCO is also ready for enterprise-level challenges.

The POCO libraries free developers from re-inventing the wheel, and allow them to spend their time on more worthwhile areas, such as getting things done quickly and working on the features that make their application unique.

Gnome Devtool Libraries project contains components and libraries that are intended to be shared between GNOME development tools, including gnome-debug,
gnome-build, and anjuta2.

The current pieces of GDL include:

- A symbol browser bonobo component (symbol-browser-control).

- A docking widget (gdl).

- A utility library that also contains the stubs and skels for the symbol browser and text editor components (gdl, idl).

Discussion of GDL development takes place on the gnome-devtools@gnome.org
mailing list and on #devel-apps at irc.gnome.org.

GDL is licensed under the terms of the GPL.

Installation:

The simplest way to compile this package is:

1. `cd to the directory containing the packages source code and type `./configure to configure the package for your system. If youre using `csh on an old version of System V, you might need to type `sh ./configure instead to prevent `csh from trying to execute `configure itself.

Running `configure takes awhile. While running, it prints some messages telling which features it is checking for.

2. Type `make to compile the package.

3. Optionally, type `make check to run any self-tests that come with the package.

4. Type `make install to install the programs and any data files and documentation.

5. You can remove the program binaries and object files from the source code directory by typing `make clean. To also remove the files that `configure created (so you can compile the package for a different kind of computer), type `make distclean. There is also a `make maintainer-clean target, but that is intended mainly for the packages developers. If you use it, you may have to get all sorts of other programs in order to regenerate files that came with the distribution.

PoJoe Component Libraries project is a set of Java POJO components, originally developed for OSMQ. Developers have found these components useful in building robust enterprise applications.
Of note are: a FIFO queue that utilizes memory until a size threshold is reached, paging overflow elements to a disk cache; a dynamic discovery mechanism for locating remote processes by name over an IP network, eliminating the need to identify a remote service with a specific host computer; and a set of peer-to-peer async message components that support n concurrent message publishers for each named subscriber.
Enhancements:
- Minor enhancements and bugfixes, and changing the license from GNU Lesser to Apache 2.0.

dnshistory project provide a means for storing a history of DNS and Name changes for the IP Addresses extracted from web log files.
The major target being that multiple analyses of older log files do not require re-lookups of IP Address to FQDNs, and additionally maintain the accuracy of the lookup as it was then and not as it is now.
Main features:
- Do Lookups. The default mode. Given a web log file, dnshistory will perform DNS reverse lookups on each unique IP Address and store the results in a history database.
- Do Translations. Given a raw web log file, dnshistory will make use of a previously created history database and send to STDOUT the same web log but with addresses replaced by the Fully Qualified Domain Name as previously looked up.
- Do Recombining. Given two web log files, one raw and one previously translated (eg. by using dnstran): Create a history database from the values in these separate log files.
- Do Dump. Dump a given history database to STDOUT.
- Show History. Given one or more IP Addresses on the command line, display their history from the database.
Its quite possible that most users would only ever use the first two modes.
The lookups make use of threads for near maximum speed, and use the standard resolution libraries on a system. Thus hosts files, NIS, LDAP and other name resolution methods should work transparently. Unfortunately most other tools ignore local name resolution methods in favour of DNS lookups only.
It is strongly recommended that for massive raw lookups a DNS server is "nearby". Preferably not a forwarding server, or your upstream provider will not like you.
dnshistory can read .gz files. Any input sent via STDIN is currently assumed to not be gz encoded.
dnshistory assumes that the logs being sent are already sorted into oldest --> most_recent date/time order.
A Berkeley Database is used to store the history; as well as possibly reducing the memory footprint within a run.
dnshistory is released under the General Public License.
Enhancements:
- This is practically identical to 1.3-beta1.

Rails History Plugin is a Ruby on Rails plugin that stores user actions (i.e. URLs that the user has recently visited).
It avoids storage of POST and AJAX requests, and it provides a manual way to specify which actions not to store.
Installation:
Unpack into the vendor/plugin and that should be it.
Usage:
In your app/controllers/application_controller.rb, add a history line like this:
class ApplicationController < ActionController::Base
history :default => "http://default.url.com/",
:max => 10
end
The history function accepts a hash of options
:default, the default URL to redirect
:max, the maximum locations to remember (five by defaults).
None of the parameters are required. If somebody knows of a better way to obtain the default URL, he is welcomed to tell me how.
You can use the method history_skip in your controller if you want to avoid certain location to be stored in the history. By default, action resulting from a POST, PUT, DELETE request or an Ajax request are not stored in the history.
class FooController < ApplicationController
history_skip :action_to_skip
def action_to_skip
# I will not be stored in the history
end
end
In your actions, you can then use the following methods:
last_location: returns the last visited location, can be used with one numeric argument precising how many locations to go back in the history (1 by default),
peek_last_location: like last_location but dont remove it from the history,
redirect_back: redirect the user to the last location in history, it takes the same arguments as last_location,
store_location(force = false): stores the current location in the history, set force parameter to true to store location even if it would be skipped.
Note that if you want to use the plugin to create a "back" link on a page, you must go back two times. For example, using this controller
class HistoryController < ApplicationController
def foo
end
def bar
end
def back
redirect_back(2)
end
end
Ill try to explain clearly why. Lets say that in your bar view, you create a back link wich links to the back action. Now a user visits foo then bar. What you want is your user being redirected to foo when clicking your "back" link. Now your user hits the link. The controller will call the back action. From its point of view, you are in the back action so going back one time would take you to the bar action.
Enhancements:
- This release fixes a bug where a user variable was stored in a class variable instead of a session one, so a user going back would make another one skip a page in its history.
- The plugin no longer stores PUT and DELETE requests.
- A peek_last_location method was added to look at the history without modifying it, and a "force" parameter was added to the store_location method to force storing of a location even if it would normally be skipped.

CVS History is a Web application for searching the history of CVS actions. It parses the output of the CVS history command and imports it into a MySQL database for ease of manipulation by the PHP front-end.
Its advantage over other CVS history viewing applications is that it only needs anonymous CVS access to the repository.
Main features:
- Tested on Firefox and IE
- XHTML and CSS validated code
- RSS feed of the search query results
- Export the output of search query to other formats (e.g. CSV file)
- Searches can be bookmarked
- History entries can be linked to a ViewVC installation of the same repository

Standard Portable Library is a pointer friendly C/C++ STL substitute. The API is similar to Java or .NET and includes common data structures, networking, and database support.