Free relationship diagram software for linux

Bio::Ontology::Relationship is a relationship for an ontology.

SYNOPSIS

$rel = Bio::Ontology::Relationship->new( -identifier => "16847",
-subject_term => $subj,
-object_term => $obj,
-predicate_term => $pred );

This is a basic implementation of Bio::Ontology::RelationshipI.

The terminology we use here is the one commonly used for ontologies, namely the triple of (subject, predicate, object), which in addition is scoped in a namespace (ontology). It is called triple because it is a tuple of three ontology terms.

There are other terminologies in use for expressing relationships. For those who it helps to better understand the concept, the triple of (child, relationship type, parent) would be equivalent to the terminology chosen here, disregarding the question whether the notion of parent and child is sensible in the context of the relationship type or not. Especially in the case of ontologies with a wide variety of predicates the parent/child terminology and similar ones can quickly become ambiguous (e.g., A synthesises B), meaningless (e.g., A binds B), or even conflicting (e.g., A is-parent-of B), and are therefore strongly discouraged.

Firefly CRM is a Web-based customer relationship management system to keep track of customers and their companies. Each entry can have a list of actions to be done and items tjat have been done. Firefly CRM can also be used to send emails to your customers.
Main features:
- CRM - Store contact / customer details
- CRM - Arrange contacts into groups of your choosing
- CRM - Schedule actions to do for contacts and for groups
- CRM - E-mail reminders to your inbox for scheduled actions
- CRM - Send e-mails to either individual contacts or to groups
- CRM Keeps history of all actions completed
Enhancements:
- Various bugs were fixed.

Autodia::Handler::Torque Perl module contains an AutoDia handler for Torque xml database schema.

This provides Autodia with the ability to read Torque Database Schema files, allowing you to convert them via the Diagram Export methods to images (using GraphViz and VCG) or html/xml using custom templates or to Dia.

SYNOPSIS

use Autodia::Handler::Torque;

my $handler = Autodia::Handler::dia->New(%Config);

$handler->Parse(filename); # where filename includes full or relative path.

Description

The Torque handler will parse the xml file using XML::Simple and populating the diagram object with class, superclass, and relationships representing tables and relationships.

The Torque handler is registered in the Autodia.pm module, which contains a hash of language names and the name of their respective language.

An example Torque database schema is shown here - its actually a rather nice format apart from the Java studlyCaps..

< ?xml version="1.0" encoding="ISO-8859-1" standalone="no" ? >
< !DOCTYPE database SYSTEM "http://db.apache.org/torque/dtd/database_3_0_1.dtd" >
< database name="INTERPLANETARY" >
< table name="CIVILIZATION" >
< column name="CIV_ID" required="true" autoIncrement="true" primaryKey="true" type="INTEGER"/ >
< column name="NAME" required="true" type="LONGVARCHAR"/ >
< /table >

< table name="CIV_PEOPLE" >
< column name="CIV_ID" required="true" primaryKey="true" type="INTEGER"/ >
< column name="PEOPLE_ID" required="true" primaryKey="true" type="INTEGER"/ >

< foreign-key foreignTable="CIVILIZATION" >
< reference local="CIV_ID" foreign="CIV_ID"/ >
< /foreign-key >
< foreign-key foreignTable="PEOPLE" >
< reference local="PEOPLE_ID" foreign="PEOPLE_ID"/ >
< /foreign-key >
< /table >

< table name="PEOPLE" >
< column name="PEOPLE_ID" required="true" autoIncrement="true" primaryKey="true" type="INTEGER"/ >
< column name="NAME" required="true" size="255" type="VARCHAR"/ >
< column name="SPECIES" type="INTEGER" default="-2"/ >
< column name="PLANET" type="INTEGER" default="-1"/ >
< /table >
< /database >

Clara is a help-documentation tool for C++ or java developers. Basically she paints a diagram - a clara diagram - from a class.

With clara you can visualize your class as if it were a chip with pins for input - representing the input parameters of the methods - and pins for output - representing the return type of the functions-.

Lets see for example the diagram that clara would draw for the following C++ sample class

class sampleInterface
{
public:

void init (MyStructure * pstruct);

void setPoint (float x, float y);

float getX ();
float getY ();

void processIt ();
};

What are these pins for ? Are we going to connect them somehow ? Not at all, it is just a convenient way to represent what the class offers in a very compact form.

Of course the diagram will be drawn by clara automatically, there is no need (and no chance) of manually drawing anything.

Clara gets the needed information in two ways : using reflection in java and parsing the header file in C++. Clara can also draw a call-diagram of the class if the sources are found, note though that for the call-diagram an extra tool is needed (dot.exe from http://www.graphviz.org) and it has to be installed apart.

Algorithm::SixDegrees is a Perl module that can find a path through linked elements in a set.

SYNOPSIS

use Algorithm::SixDegrees;

my $sd1 = Algorithm::SixDegrees->new();
$sd1->data_source( actors => &starred_in );
$sd1->data_source( movies => &stars_of );
@elems = $sd1->make_link(actors, Tom Cruise, Kevin Bacon);

my $sd2 = Algorithm::SixDegrees->new();
$sd2->forward_data_source( friends => &friends, @args );
$sd2->reverse_data_source( friends => &friend_of, @args );
@elems = $sd2->make_link(friends, Bob, Mark);

Algorithm::SixDegrees is a Perl implementation of a breadth-first search through a set of linked elements in order to find the shortest possible chain linking two specific elements together.

In simpler terms, this module will take a bunch of related items and attempt to find a relationship between two of them. It looks for the shortest (and generally, simplest) relationship it can find.

Hydrate is a Java tool that provides for fast efficient and error-free transformation of data between three different representations: relational databases, objects in an object-oriented programming language and extended markup language (XML).
Each of these representations has its strengths and weaknesses as shown in the diagram below; but which should you use as a basis for your application design?
Hydrate relaxes some of the pressure on this decision by providing tools for moving data from one representation to another, guided by a master UML class representation of that data.
- You want to lay a domain object model view over an existing database or set of databases. Hydrate gives you the tools to design that model in UML and map your existing data to that model. Once in the object space, you can perform complex manipulations on the objects, calculate results and save information back to a relational cache for searching or reloading, as well as converting the results to XML for sending to downstream systems or transforming to a readable format for display.
- Your project involves taking various data files fed from external systems that you want to pull into an object model on your server before writing the results down to a fully relational database. You can now respond to requests from external systems by rehydrating the data from its relational form and sending it out as XML documents or transforming those documents to a readable format for display.
- You are building a data warehouse in which you have the broad specifications for the model, but want to provide for flexibility and adaptability for future unpredicted requests. Based on a core data model, Hydrate gives you the tools to create you database schema, and write information to it, but more significantly to subsequently lay a completely different object model perhaps aggregating some of the data over the top of that schema to process it in unforeseen ways.
- You need to integrate data from many different data sources in a highly performant manner. SQL permits you to read a huge data set a row at a time and perform running calculations and filtering on that data. But the performance pressures can lead to code that is highly coupled with the database and what do you do if you need to integrate data from elsewhere in order to complete your calculations? Hydrate permits you to operate in the object space and integrate information from other sources on-the-fly.
Main features:
- To integrate legacy and other data schemas over which you have little control. Map data from many different data sources into a single self-consistent in-memory model. Different parts of the same object, as well as different sub-populations of the same object type can be drawn from different data sources, different schemas and even different database architectures.
- Load, populate and connect up multiple object types from a single query. There is no limit to the number of object types that can be loaded from a single query, or to the complexity of the relationships that can be resolved between them. Objects read from a query are automatically merged into objects already in memory.
- Full control over the SQL that runs against the database (if you need it). Any SQL queries simultaneously from multiple JDBC drivers, even using database specific optimizations, as long as they returns a result set.
- Access and manipulate the same data through the rich and powerful XML toolset. Use the same meta data that describes your objects to easily read from, write to and validate any consistent XML schema. Use XML for display, data transmission or XSLT transformation. Load XML data back into objects.
- Highly optimized performance for reading and writing SQL and XML. Since native types are used and SQL chatter is non-existent, database performance is comparable with doing the mapping by hand. XML reading and writing uses SAX exclusively.

JGraphpad is a diagram editor for Swing that offers the functionality to create flow charts, maps, and UML diagrams.
This release compiles with JGraph 5.7.3.1. Toolbox buttons to create edges or vertices no longer persist selection state. The former behaviour can be restored by setting GPMarqueeHandler.remanent to true.
The GPMarqueeHandler, GPGraph, DefaultGraphModelFileFormatXML, and GPUserObject classes were moved to org.jgraph and their constructors are now protected so that JGraphpad is easier to extend from as a library without changing its code. Various warnings were removed and a general code cleanup undertaken.
Main features:
- Export to XML and JPG
- Built-in Object Library
- Overview
- Interactive Layout
- Print Support
- Page View
- Automatic Zoom
- Grid
- Drag and Drop
- Search
- Minimum Spanning Tree
- Shortest Path
- Component Count
- Background Image