Free class libraries software for linux

LBC Libraries is a set of easy C libraries that provide classical data types and structures (string, hash, queue, stack, tree).
LBC Libraries package is focused on simplicity and portability. It uses ANSI C (C98 standard not required), and provides the most generic approach possible so that queues can have items of different types, hashes can have keys of different data types, trees can be binary trees or have arbitrary numbers of branches, etc.
Enhancements:
- This release adds minor API changes, enhances the documentation, and fixes major bugs in LBCstring.

DAEMon Raco Libraries (DRLibs) is a collection of useful functions, objects, and routines for C++.
Enhancements:
- This release adds new libraries to manage object lists: doublelist.dr.h, simplelist.dr.h, and sortedlist.dr.h.

Dynamic Probe Class Library (DPCL) is an object-based C++ class library that provides the necessary infrastructure to allow tool developers and sophisticated tool users to build parallel and serial tools through technology called dynamic instrumentation.
Dynamic Probe Class Library takes the basic components needed by tool developers and encapsulates them into C++ classes. Each of these classes provide the member functions necessary to interact and dynamically instrument a running application with software patches called probes.
Dynamic instrumentation provides the flexibility for tools to insert probes into applications as the application is running and only where it is needed.
Enhancements:
- This version is a minor update to DPCL that fixes a couple problems that have been reported since the v3.4.2 release

Class::ArrayObjects is a Perl utility class for array based objects.

SYNOPSIS

package Some::Class;
use Class::ArrayObjects define => {
fields => [qw(_foo_ _bar_ BAZ)],
};

or

package Other::Class;
use base Some::Class;
use Class::ArrayObjects extend => {
class => Some::Class,
with => [qw(_zorg_ _fnord_ BEZ)],
import => 1,
};

This module is little more than a cute way of defining constant subs in your own package. Constant subs are very useful when dealing with array based objects because they allow one to access array slots by name instead of by index.

Easy Game Library is library of C++ classes designed to make game programming easier. Now it consists only of easy_sprite library which consists of classes for using sprites.

It should compile on different platforms because it uses SDL library as backend.

Installation:

To install run such sequence of commands:

make - Compiles library and tests

make install - Installs library and tests

GOBLIN is a C++ class library focussed on graph optimization and network programming problems. GOBLIN Graph Library deals with all of the standard graph optimization problems discussed by textbooks and in courses on combinatorial optimization.
This software package also consists of a shell interpreter which extends the well-known Tcl/Tk language to graph objects and a graph browser and editor tool. Executable solvers are available for practical optimization problems. The graph browser applies for teaching and scientific documentation purposes.
GOBLIN is open source software and licenced by the GNU Lesser Public License (LGPL). That is, GOBLIN may be downloaded, compiled and used for scientific, educational and other purposes free of charge. For details, in particular the statements about redistribution and changes of the source code, observe the LGPL document which is attached to the package.
Main features:
- The gosh interpreter extends the Tcl/Tk scripting language to graph objects in a natural way.
- The goblet graph browser and editor tool. Graphical front end to the library.
- An open class hierarchy which strictly separates between abstract classes (all mathematical algorithms are defined as methods of abstract classes), implementations (i.e. by incidence lists, adjacency matrices) and logical views (problem transformations).
- A generic branch and bound module with several applications to graph optimization.
- Logging and tracing functionality which allows to study the various algorithms by examples.
- A runtime configuration module controls the selection of mathemetical methods, logging information, and the tracing of data objects.
- Compile time configuration module for code optimization.
- A file interface which can be easily extended to new problem classes.
- Source code for executable solver programs.
Today, GOBLIN provides strongly polynomial algorithms for the following graph optimization problems:
- Shortest paths in graphs and digraphs with negative lengths.
- Negative cycles and minimum mean cycles.
- Strong and 2-connected components.
- Minimum spanning trees, arborescences and 1-trees.
- Maximum st-flows, feasible circulations and b-flows.
- Min-cost st-flows, b-flows and circulations.
- Assignment problems of any kind.
- 1-matchings, b-matchings, capacitated b-matchings, f-factors and degree-constrained subgraphs.
- Directed and undirected Chinese postman problems, T-joins.
Enhancements:
- This release comes with explicit code for orthogonal drawing of trees.
- There are also new generator methods for regular planara graphs.
- A lot of doxygen comments has been added, but dexcription are still far from complete.

Memory Structures Library (MemSL) is a complete data structures/collection classes library with memory tracing, memory debugging, entry/exit tracing, exception handling, definable memory handlers, built-in thread support, and much more.

The project supports single, double, and circular linked lists, AVL balanced and threaded binary trees, dynamic hashing tables, stacks, queues and dequeues (using arrays or linked lists), sets (Pascal implementation, with union, difference, intersection, etc.), bags, tables and dictionaries, priority heaps, priority search queue, and more.

Class::Cloneable is a base class for Cloneable objects.

SYNOPSIS

package MyObject;
our @ISA = (Class::Cloneable);

# calling clone on an instance of MyObject
# will give you full deep-cloning functionality

This module provides a flexible base class for building objects with cloning capabilities. This module does its best to respect the encapsulation of all other objects, including subclasses of itself. This is intended to be a stricter and more OO-ish option than the more general purpose Clone and Clone::PP modules.