/[cvs]/nfo/perl/libs/Data/Storage.pm
ViewVC logotype

Diff of /nfo/perl/libs/Data/Storage.pm

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 1.1 by cvsjoko, Thu Oct 10 03:43:12 2002 UTC revision 1.13 by joko, Tue Dec 17 21:54:12 2002 UTC
# Line 1  Line 1 
1  #################################  # $Id$
2  #  #
3  #  $Id$  # Copyright (c) 2002  Andreas Motl <andreas.motl@ilo.de>
4    #
5    # See COPYRIGHT section in pod text below for usage and distribution rights.
6    #
7    ############################################
8  #  #
9  #  $Log$  #  $Log$
10    #  Revision 1.13  2002/12/17 21:54:12  joko
11    #  + feature when using Tangram:
12    #    + what? each object created should delivered with a globally(!?) unique identifier (GUID) besides the native tangram object id (OID)
13    #        + patched Tangram::Storage (jonen)
14    #        + enhanced Data::Storage::Schema::Tangram (joko)
15    #        + enhanced Data::Storage::Handler::Tangram 'sub getObjectByGuid' (jonen)
16    #    + how?
17    #        + each concrete (non-abstract) class gets injected with an additional field/property called 'guid' - this is done (dynamically) on schema level
18    #        + this property ('guid') gets filled on object creation/insertion from 'sub Tangram::Storage::_insert' using Data::UUID from CPAN
19    #        + (as for now) this property can get accessed by calling 'getObjectByGuid' on the already known storage-handle used throughout the application
20    #
21    #  Revision 1.12  2002/12/12 02:50:15  joko
22    #  + this now (unfortunately) needs DBI for some helper functions
23    #  + TODO: these have to be refactored to another scope! (soon!)
24    #
25    #  Revision 1.11  2002/12/11 06:53:19  joko
26    #  + updated pod
27    #
28    #  Revision 1.10  2002/12/07 03:37:23  joko
29    #  + updated pod
30    #
31    #  Revision 1.9  2002/12/01 22:15:45  joko
32    #  - sub createDb: moved to handler
33    #
34    #  Revision 1.8  2002/11/29 04:48:23  joko
35    #  + updated pod
36    #
37    #  Revision 1.7  2002/11/17 06:07:18  joko
38    #  + creating the handler is easier than proposed first - for now :-)
39    #  + sub testAvailability
40    #
41    #  Revision 1.6  2002/11/09 01:04:58  joko
42    #  + updated pod
43    #
44    #  Revision 1.5  2002/10/29 19:24:18  joko
45    #  - reduced logging
46    #  + added some pod
47    #
48    #  Revision 1.4  2002/10/27 18:35:07  joko
49    #  + added pod
50    #
51    #  Revision 1.3  2002/10/25 11:40:37  joko
52    #  + enhanced robustness
53    #  + more logging for debug-levels
54    #  + sub dropDb
55    #
56    #  Revision 1.2  2002/10/17 00:04:29  joko
57    #  + sub createDb
58    #  + sub isConnected
59    #  + bugfixes regarding "deep recursion" stuff
60    #
61  #  Revision 1.1  2002/10/10 03:43:12  cvsjoko  #  Revision 1.1  2002/10/10 03:43:12  cvsjoko
62  #  + new  #  + new
63  #  #
64  #  ############################################
65  #################################  
66    
67    BEGIN {
68      $Data::Storage::VERSION = 0.02;
69    }
70    
71    
72    =head1 NAME
73    
74      Data::Storage - Interface for accessing various Storage implementations for Perl in an independent way
75    
76    
77    =head1 AIMS
78    
79      - should encapsulate Tangram, DBI, DBD::CSV and LWP:: to access them in an unordinary (more convenient) way ;)
80      - introduce a generic layered structure, refactor *SUBLAYER*-stuff, make (e.g.) this possible:
81        Perl Data::Storage[DBD::CSV]  ->  Perl LWP::  ->  Internet HTTP/FTP/*  ->  Host Daemon  ->  csv-file
82      - provide generic synchronization mechanisms across arbitrary/multiple storages based on ident/checksum
83        maybe it's possible to have schema-, structural- and semantical modifications synchronized???
84    
85    
86    =head1 SYNOPSIS
87    
88    =head2 BASIC ACCESS
89    
90    =head2 ADVANCED ACCESS
91    
92      ... via inheritance:
93      
94        use Data::Storage;
95        my $proxyObj = new HttpProxy;
96        $proxyObj->{url} = $url;
97        $proxyObj->{payload} = $content;
98        $self->{storage}->insert($proxyObj);
99        
100        use Data::Storage;
101        my $proxyObj = HttpProxy->new(
102          url => $url,
103          payload => $content,
104        );
105        $self->{storage}->insert($proxyObj);
106    
107    
108    =head2 SYNCHRONIZATION
109    
110      my $nodemapping = {
111        'LangText' => 'langtexts.csv',
112        'Currency' => 'currencies.csv',
113        'Country'  => 'countries.csv',
114      };
115    
116      my $propmapping = {
117        'LangText' => [
118          [ 'source:lcountrykey'  =>  'target:country' ],
119          [ 'source:lkey'         =>  'target:key' ],
120          [ 'source:lvalue'       =>  'target:text' ],
121        ],
122        'Currency' => [
123          [ 'source:ckey'         =>  'target:key' ],
124          [ 'source:cname'        =>  'target:text' ],
125        ],
126        'Country' => [
127          [ 'source:ckey'         =>  'target:key' ],
128          [ 'source:cname'        =>  'target:text' ],
129        ],
130      };
131    
132      sub syncResource {
133    
134        my $self = shift;
135        my $node_source = shift;
136        my $mode = shift;
137        my $opts = shift;
138        
139        $mode ||= '';
140        $opts->{erase} ||= 0;
141        
142        $logger->info( __PACKAGE__ . "->syncResource( node_source $node_source mode $mode erase $opts->{erase} )");
143      
144        # resolve metadata for syncing requested resource
145        my $node_target = $nodemapping->{$node_source};
146        my $mapping = $propmapping->{$node_source};
147        
148        if (!$node_target || !$mapping) {
149          # loggger.... "no target, sorry!"
150          print "error while resolving resource metadata", "\n";
151          return;
152        }
153        
154        if ($opts->{erase}) {
155          $self->_erase_all($node_source);
156        }
157      
158        # create new sync object
159        my $sync = Data::Transfer::Sync->new(
160          storages => {
161            L => $self->{bizWorks}->{backend},
162            R => $self->{bizWorks}->{resources},
163          },
164          id_authorities        =>  [qw( L ) ],
165          checksum_authorities  =>  [qw( L ) ],
166          write_protected       =>  [qw( R ) ],
167          verbose               =>  1,
168        );
169        
170        # sync
171        # todo: filter!?
172        $sync->syncNodes( {
173          direction       =>  $mode,                 # | +PUSH | +PULL | -FULL | +IMPORT | -EXPORT
174          method          =>  'checksum',            # | -timestamp | -manual
175          source          =>  "L:$node_source",
176          source_ident    =>  'storage_method:id',
177          source_exclude  =>  [qw( id cs )],
178          target          =>  "R:$node_target",
179          target_ident    =>  'property:oid',
180          mapping         =>  $mapping,
181        } );
182    
183      }
184    
185    
186    =head2 NOTE
187    
188      This module heavily relies on DBI and Tangram, but adds a lot of additional bugs and quirks.
189      Please look at their documentation and/or this code for additional information.
190    
191    
192    =head1 REQUIREMENTS
193    
194      For full functionality:
195        DBI              from CPAN
196        DBD::mysql       from CPAN
197        Tangram 2.04     from CPAN         (hmmm, 2.04 won't do in some cases)
198        Tangram 2.05     from http://...   (2.05 seems okay but there are also additional patches from our side)
199        Class::Tangram   from CPAN
200        DBD::CSV         from CPAN
201        MySQL::Diff      from http://adamspiers.org/computing/mysqldiff/
202        ... and all their dependencies
203    
204    =cut
205    
206    # The POD text continues at the end of the file.
207    
208    
209  package Data::Storage;  package Data::Storage;
210    
# Line 15  use strict; Line 212  use strict;
212  use warnings;  use warnings;
213    
214  use Data::Storage::Locator;  use Data::Storage::Locator;
215  use Data::Storage::Handler::DBI;  use Data::Dumper;
216  use Data::Storage::Handler::Tangram;  
217    # TODO: wipe out!
218    use DBI;
219    
220    # TODO: actually implement level (integrate with Log::Dispatch)
221    my $TRACELEVEL = 0;
222    
223  # get logger instance  # get logger instance
224  my $logger = Log::Dispatch::Config->instance;  my $logger = Log::Dispatch::Config->instance;
# Line 25  sub new { Line 227  sub new {
227    my $invocant = shift;    my $invocant = shift;
228    my $class = ref($invocant) || $invocant;    my $class = ref($invocant) || $invocant;
229    #my @args = normalizeArgs(@_);    #my @args = normalizeArgs(@_);
230      
231    my $arg_locator = shift;    my $arg_locator = shift;
232    my $arg_options = shift;    my $arg_options = shift;
233      
234    #my $self = { STORAGEHANDLE => undef, @_ };    #my $self = { STORAGEHANDLE => undef, @_ };
235    my $self = { STORAGEHANDLE => undef, locator => $arg_locator, options => $arg_options };    my $self = { STORAGEHANDLE => undef, locator => $arg_locator, options => $arg_options };
236    $logger->debug( __PACKAGE__ . "[$self->{locator}->{type}]" . "->new(@_)" );    #$logger->debug( __PACKAGE__ . "[$self->{locator}->{type}]" . "->new(@_)" );
237      $logger->debug( __PACKAGE__ . "[$arg_locator->{type}]" . "->new(@_)" );
238    return bless $self, $class;    return bless $self, $class;
239  }  }
240    
241  sub AUTOLOAD {  sub AUTOLOAD {
242        
243      # since this is a core function acting as dispatcher to $self->{STORAGEHANDLE},
244      # some sophisticated handling and filtering is needed to avoid things like
245      #     - Deep recursion on subroutine "Data::Storage::AUTOLOAD"
246      #     - Deep recursion on subroutine "Data::Storage::Handler::Abstract::AUTOLOAD"
247      #     - Deep recursion on anonymous subroutine at [...]
248      # we also might filter log messages caused by logging to itself in "advanced logging of AUTOLOAD calls"
249      
250    my $self = shift;    my $self = shift;
251    our $AUTOLOAD;    our $AUTOLOAD;
252        
# Line 46  sub AUTOLOAD { Line 256  sub AUTOLOAD {
256    my $method = $AUTOLOAD;    my $method = $AUTOLOAD;
257    $method =~ s/^.*:://;    $method =~ s/^.*:://;
258    
259    #$logger->debug( __PACKAGE__ . "[$self->{locator}->{type}]" . "->" . $method . "(@_)" . " (AUTOLOAD)" );    # advanced logging of AUTOLOAD calls ...
260      # ... nice but do it only when TRACING (TODO) is enabled
261        if ($TRACELEVEL) {
262          my $logstring = "";
263          $logstring .= __PACKAGE__ . "[$self->{locator}->{type}]" . "->" . $method;
264          #print "count: ", $#_, "\n";
265          #$logstring .= Dumper(@_) if ($#_ != -1);
266          my $tabcount = int( (80 - length($logstring)) / 10 );
267          $logstring .= "\t" x $tabcount . "(AUTOLOAD)";
268          # TODO: only ok if logstring doesn't contain
269          #            e.g. "Data::Storage[Tangram]->insert(SystemEvent=HASH(0x5c0034c))          (AUTOLOAD)"
270          # but that would be _way_ too specific as long as we don't have an abstract handler for this  ;)
271          $logger->debug( $logstring );
272          #print join('; ', @_);
273        }
274        
275      # filtering AUTOLOAD calls and first-time-touch of the actual storage impl
276    if ($self->_filter_AUTOLOAD($method)) {    if ($self->_filter_AUTOLOAD($method)) {
277        #print "_accessStorage\n";
278      $self->_accessStorage();      $self->_accessStorage();
279      $self->{STORAGEHANDLE}->$method(@_);      $self->{STORAGEHANDLE}->$method(@_);
280    }    }
# Line 79  sub normalizeArgs { Line 305  sub normalizeArgs {
305  sub _accessStorage {  sub _accessStorage {
306    my $self = shift;    my $self = shift;
307    # TODO: to some tracelevel!    # TODO: to some tracelevel!
308    #$logger->debug( __PACKAGE__ .  "[$self->{type}]" . "->_accessStorage()" );    if ($TRACELEVEL) {
309        $logger->debug( __PACKAGE__ .  "[$self->{locator}->{type}]" . "->_accessStorage()" );
310      }
311    if (!$self->{STORAGEHANDLE}) {    if (!$self->{STORAGEHANDLE}) {
312      $self->_createStorageHandle();      $self->_createStorageHandle();
313    }    }
# Line 87  sub _accessStorage { Line 315  sub _accessStorage {
315    
316  sub _createStorageHandle {  sub _createStorageHandle {
317    my $self = shift;    my $self = shift;
   
318    my $type = $self->{locator}->{type};    my $type = $self->{locator}->{type};
319    $logger->debug( __PACKAGE__ .  "[$type]" . "->_createStorageHandle()" );    $logger->debug( __PACKAGE__ .  "[$type]" . "->_createStorageHandle()" );
320    
321    my $pkg = "Data::Storage::Handler::" . $type . "";    my $pkg = "Data::Storage::Handler::" . $type . "";
322        
323    # propagate args to handler    # try to load perl module at runtime
324    # needs some more thoughts! (not only "dbi" to Tangram, when (in future) db is not more the common case)    my $evalstr = "use $pkg;";
325    if ($type eq 'DBI') {    eval($evalstr);
326      #my @args = %{$self->{locator}->{dbi}};    if ($@) {
327      my @args = %{$self->{locator}};      $logger->error( __PACKAGE__ .  "[$type]" . "->_createStorageHandle(): $@" );
328      $self->{STORAGEHANDLE} = $pkg->new( @args );      return;
   }  
   if ($type eq 'Tangram') {  
     #$self->{STORAGEHANDLE} = $pkg->new( dsn => $self->{locator}->{dbi}->{dsn} );  
     #my @args = %{$self->{locator}->{dbi}};  
     my @args = %{$self->{locator}};  
     $self->{STORAGEHANDLE} = $pkg->new( @args );  
     #$self->{STORAGEHANDLE_UNDERLYING} = $self->{STORAGEHANDLE}->getUnderlyingStorage();  
     #$self->{STORAGEHANDLE_UNDERLYING}->_configureCOREHANDLE();  
329    }    }
330        
331      # build up some additional arguments to pass on
332      #my @args = %{$self->{locator}};
333      my @args = ();
334    
335      # - create new storage handle object
336      # - propagate arguments to handler
337      # - pass locator by reference to be able to store status- or meta-information in it
338      $self->{STORAGEHANDLE} = $pkg->new( locator => $self->{locator}, @args );
339    
340  }  }
341    
342  sub addLogDispatchHandler {  sub addLogDispatchHandler {
# Line 116  sub addLogDispatchHandler { Line 344  sub addLogDispatchHandler {
344        my $self = shift;        my $self = shift;
345        my $name = shift;        my $name = shift;
346        my $package = shift;        my $package = shift;
347        my $logger = shift;        my $logger1 = shift;
348        my $objectCreator = shift;        my $objectCreator = shift;
349                
350        #$logger->add( Log::Dispatch::Tangram->new( name => $name,        #$logger->add( Log::Dispatch::Tangram->new( name => $name,
# Line 140  sub addLogDispatchHandler { Line 368  sub addLogDispatchHandler {
368  }  }
369    
370  sub removeLogDispatchHandler {  sub removeLogDispatchHandler {
371      my $self = shift;
372        my $self = shift;    my $name = shift;
373        my $name = shift;    #my $logger = shift;
374        my $logger = shift;    $logger->remove($name);
   
       $logger->remove($name);  
   
375  }  }
376    
377  sub getDbName {  sub getDbName {
# Line 157  sub getDbName { Line 382  sub getDbName {
382    return $database_name;    return $database_name;
383  }  }
384    
385    sub testAvailability {
386      my $self = shift;
387      my $status = $self->testDsn();
388      $self->{locator}->{status}->{available} = $status;
389      return $status;
390    }
391    
392    sub isConnected {
393      my $self = shift;
394      # TODO: REVIEW!
395      return 1 if $self->{STORAGEHANDLE};
396    }
397    
398  sub testDsn {  sub testDsn {
399    my $self = shift;    my $self = shift;
400    my $dsn = $self->{locator}->{dbi}->{dsn};    my $dsn = $self->{locator}->{dbi}->{dsn};
# Line 164  sub testDsn { Line 402  sub testDsn {
402    if ( my $dbh = DBI->connect($dsn, '', '', {    if ( my $dbh = DBI->connect($dsn, '', '', {
403                                                        PrintError => 0,                                                        PrintError => 0,
404                                                        } ) ) {                                                        } ) ) {
405        
406        # TODO: REVIEW
407      $dbh->disconnect();      $dbh->disconnect();
408        
409      return 1;      return 1;
410    } else {    } else {
411      $logger->error( __PACKAGE__ .  "[$self->{locator}->{type}]" . "->testDsn(): " . "DBI-error: " . DBI::errstr );      $logger->warning( __PACKAGE__ .  "[$self->{locator}->{type}]" . "->testDsn(): " . "DBI-error: " . $DBI::errstr );
412      }
413    }
414    
415    sub dropDb {
416      my $self = shift;
417      my $dsn = $self->{locator}->{dbi}->{dsn};
418    
419      $logger->debug( __PACKAGE__ .  "->dropDb( dsn $dsn )" );
420    
421      $dsn =~ s/database=(.+?);//;
422      my $database_name = $1;
423    
424      my $ok;
425      
426      if ( my $dbh = DBI->connect($dsn, '', '', {
427                                                          PrintError => 0,
428                                                          } ) ) {
429        if ($database_name) {
430          if ($dbh->do("DROP DATABASE $database_name;")) {
431            $ok = 1;
432          }
433        }
434    
435        $dbh->disconnect();
436    
437    }    }
438      
439      return $ok;
440  }  }
441    
 1;  
442    1;
443    __END__
444    
445    
446    =head1 DESCRIPTION
447    
448    =head2 Data::Storage
449    
450      Data::Storage is a module for accessing various "data structures / kinds of structured data" stored inside
451      various "data containers".
452      We tried to use the AdapterPattern (http://c2.com/cgi/wiki?AdapterPattern) to implement a wrapper-layer
453      around core CPAN modules (Tangram, DBI).
454    
455    =head2 Why?
456    
457      You will get a better code-structure (not bad for later maintenance) in growing Perl code projects,
458      especially when using multiple database connections at the same time.
459      You will be able to switch between different _kinds_ of implementations used for storing data.
460      Your code will use the very same API to access these storage layers.
461          ... implementation has to be changed for now
462      Maybe you will be able to switch "on-the-fly" without changing any bits in code in the future....
463          ... but that's not the focus
464    
465    =head2 What else?
466    
467      Having this, we were able to do implement a generic data synchronization module more easy,
468      please look at Data::Transfer.
469    
470    
471    =head1 AUTHORS / COPYRIGHT
472    
473      The Data::Storage module is Copyright (c) 2002 Andreas Motl.
474      All rights reserved.
475      You may distribute it under the terms of either the GNU General Public
476      License or the Artistic License, as specified in the Perl README file.
477    
478    
479    =head1 ACKNOWLEDGEMENTS
480    
481      Larry Wall for Perl, Tim Bunce for DBI, Jean-Louis Leroy for Tangram and Set::Object,
482      Sam Vilain for Class::Tangram, Jochen Wiedmann and Jeff Zucker for DBD::CSV & Co.,
483      Adam Spiers for MySQL::Diff and all contributors.
484    
485    
486    =head1 SUPPORT / WARRANTY
487    
488      Data::Storage is free software. IT COMES WITHOUT WARRANTY OF ANY KIND.
489    
490    
491    =head1 TODO
492    
493    
494    =head2 BUGS
495    
496    "DBI-Error [Tangram]: DBD::mysql::st execute failed: Unknown column 't1.requestdump' in 'field list'"
497    
498      ... occours when operating on object-attributes not introduced yet:
499      this should be detected and appended/replaced through:
500      "Schema-Error detected, maybe (just) an inconsistency.
501      Please check if your declaration in schema-module "a" matches structure in database "b" or try to run"
502      db_setup.pl --dbkey=import --action=deploy
503    
504    
505    Compare schema (structure diff) with database ...
506    
507      ... when issuing "db_setup.pl --dbkey=import --action=deploy"
508      on a database with an already deployed schema, use an additional "--update" then
509      to lift the schema inside the database to the current declared schema.
510      You will have to approve removals and changes on field-level while
511      new objects and new fields are introduced silently without any interaction needed.
512      In future versions there may be additional options to control silent processing of
513      removals and changes.
514      See this CRUD-table applying to the actions occouring on Classes and Class variables when deploying schemas,
515      don't mix this up with CRUD-actions on Objects, these are already handled by (e.g.) Tangram itself.
516      Classes:
517        C create    ->  yes, handled automatically
518        R retrieve  ->  no, not subject of this aspect since it is about deployment only
519        U update    ->  yes, automatically for Class meta-attributes, yes/no for Class variables (look at the rules down here)
520        D delete    ->  yes, just by user-interaction
521      Class variables:
522        C create    ->  yes, handled automatically
523        R retrieve  ->  no, not subject of this aspect since it is about deployment only
524        U update    ->  yes, just by user-interaction; maybe automatically if it can be determined that data wouldn't be lost
525        D delete    ->  yes, just by user-interaction
526      
527      It's all about not to be able to loose data simply while this is in pre-alpha stage.
528      And loosing data by being able to modify and redeploy schemas easily is definitely quite easy.
529      
530      As we can see, creations of Classes and new Class variables is handled
531      automatically and this is believed to be the most common case under normal circumstances.
532    
533    
534    =head2 FEATURES
535    
536      - Get this stuff together with UML (Unified Modeling Language) and/or standards from ODMG.
537      - Make it possible to load/save schemas in XMI (XML Metadata Interchange),
538        which seems to be most commonly used today, perhaps handle objects with OIFML.
539        Integrate/bundle this with a web-/html-based UML modeling tool or
540        some other interesting stuff like the "Co-operative UML Editor" from Uni Darmstadt. (web-/java-based)
541      - Enable Round Trip Engineering. Keep code and diagrams in sync. Don't annoy/bother the programmers.
542      - Add support for some more handlers/locators to be able to
543         access the following standards/protocols/interfaces/programs/apis transparently:
544        +  DBD::CSV (via Data::Storage::Handler::DBI)
545       (-) Text::CSV, XML::CSV, XML::Excel
546        -  MAPI
547        -  LDAP
548        -  DAV (look at PerlDAV: http://www.webdav.org/perldav/)
549        -  Mbox (use formail for seperating/splitting entries/nodes)
550        -  Cyrus (cyrdeliver - what about cyrretrieve (export)???)
551        -  use File::DiffTree, use File::Compare
552        -  Hibernate
553        -  "Win32::UserAccountDb"
554        -  "*nix::UserAccountDb"
555        -  .wab - files (Windows Address Book)
556        -  .pst - files (Outlook Post Storage?)
557        -  XML (e.g. via XML::Simple?)
558      - Move to t3, look at InCASE
559      - some kind of security layer for methods/objects
560        - acls (stored via tangram/ldap?) for functions, methods and objects (entity- & data!?)
561        - where are the hooks needed then?
562          - is Data::Storage & Co. okay, or do we have to touch the innards of DBI and/or Tangram?
563          - an attempt to start could be:
564             - 'sub getACLByObjectId($id, $context)'
565             - 'sub getACLByMethodname($id, $context)'
566             - 'sub getACLByName($id, $context)'
567                ( would require a kinda registry to look up these very names pointing to arbitrary locations (code, data, ...) )
568      - add more hooks and various levels
569      - better integrate introduced 'getObjectByGuid'-mechanism from Data::Storage::Handler::Tangram
570    
571    
572    =head3 LINKS / REFERENCES
573    
574      Specs:
575        UML 1.3 Spec: http://cgi.omg.org/cgi-bin/doc?ad/99-06-08.pdf
576        XMI 1.1 Spec: http://cgi.omg.org/cgi-bin/doc?ad/99-10-02.pdf
577        XMI 2.0 Spec: http://cgi.omg.org/docs/ad/01-06-12.pdf
578        ODMG: http://odmg.org/
579        OIFML: http://odmg.org/library/readingroom/oifml.pdf
580    
581      CASE Tools:
582        Rational Rose (commercial): http://www.rational.com/products/rose/
583        Together (commercial): http://www.oi.com/products/controlcenter/index.jsp
584        InCASE - Tangram-based Universal Object Editor
585        Sybase PowerDesigner: http://www.sybase.com/powerdesigner
586      
587      UML Editors:
588        Fujaba (free, university): http://www.fujaba.de/
589        ArgoUML (free): http://argouml.tigris.org/
590        Poseidon (commercial): http://www.gentleware.com/products/poseidonDE.php3
591        Co-operative UML Editor (research): http://www.darmstadt.gmd.de/concert/activities/internal/umledit.html
592        Metamill (commercial): http://www.metamill.com/
593        Violet (university, research, education): http://www.horstmann.com/violet/
594        PyUt (free): http://pyut.sourceforge.net/
595        (Dia (free): http://www.lysator.liu.se/~alla/dia/)
596        UMLet (free, university): http://www.swt.tuwien.ac.at/umlet/index.html
597        Voodoo (free): http://voodoo.sourceforge.net/
598        Umbrello UML Modeller: http://uml.sourceforge.net/
599    
600      UML Tools:
601        http://www.objectsbydesign.com/tools/umltools_byPrice.html
602    
603      Further readings:
604        http://www.google.com/search?q=web+based+uml+editor&hl=en&lr=&ie=UTF-8&oe=UTF-8&start=10&sa=N
605        http://www.fernuni-hagen.de/DVT/Aktuelles/01FHHeidelberg.pdf
606        http://www.enhyper.com/src/documentation/
607        http://cis.cs.tu-berlin.de/Dokumente/Diplomarbeiten/2001/skinner.pdf
608        http://citeseer.nj.nec.com/vilain00diagrammatic.html
609        http://archive.devx.com/uml/articles/Smith01/Smith01-3.asp
610    
Legend:
Removed from v.1.1  
changed lines
  Added in v.1.13
MailToCvsAdmin">MailToCvsAdmin
 ViewVC Help
Powered by ViewVC 1.1.26 RSS 2.0 feed