Hi Profis,
nachfolgend zitierte
Unit (bzw. mehrere von der Sorte) lasse ich automatisch erstellen.
Die gewünschten Strukturen (Objekte, Propertys, Beziehungen) werden vorher in einer Textdatei definiert.
Delphi-Quellcode:
unit odTournamentEvent;
interface
uses
Classes, SysUtils, od, odOlympicCustom, gOlympic
{$REGION 'USES'}, odSport, odState, odPlace, odlClubList, odlTournamentList
{$ENDREGION 'USES'};
type
TodTournamentEvent =
class(TodOlympicCustom)
private
{$REGION ' PRIVAT'}
{$REGION ' name'}
FName:
String;
{$ENDREGION ' name'}
{$REGION ' state'}
FState: TodState;
{$ENDREGION ' state'}
{$REGION ' sport'}
FSport: TodSport;
{$ENDREGION ' sport'}
{$REGION ' place'}
FPlace: TodPlace;
{$ENDREGION ' place'}
{$REGION ' clublist'}
FClubList: TodlClubList;
{$ENDREGION ' clublist'}
{$REGION ' tournamentlist'}
FTournamentList: TodlTournamentList;
{$ENDREGION ' tournamentlist'}
{$ENDREGION ' PRIVAT'}
protected
{$REGION ' PROTECTED'}
{$REGION ' name'}
function get_Name:
String;
virtual;
procedure set_Name(
const Value:
String);
virtual;
{$ENDREGION ' name'}
{$ENDREGION ' PROTECTED'}
public
constructor Create(AOwner: TComponent);
override;
destructor Destroy;
override;
{$REGION ' PUBLIC'}
{$REGION ' state'}
[AttrOd]
property State: TodState
read FState;
{$ENDREGION ' state'}
{$REGION ' sport'}
[AttrOd]
property Sport: TodSport
read FSport;
{$ENDREGION ' sport'}
{$REGION ' place'}
[AttrOd]
property Place: TodPlace
read FPlace;
{$ENDREGION ' place'}
{$REGION ' clublist'}
[AttrOd]
property ClubList: TodlClubList
read FClubList;
{$ENDREGION ' clublist'}
{$REGION ' tournamentlist'}
[AttrOd]
property TournamentList: TodlTournamentList
read FTournamentList;
{$ENDREGION ' tournamentlist'}
{$ENDREGION ' PUBLIC'}
procedure MeineGeschäftslogik;
published
end;
...
Die in den Regionen befindlichen Teile definieren die Projektdaten und Beziehungen untereinander.
Nachträglich kann ich in den Objekten die Geschäfstlogik sowie beliebige Funktionen und Felder definieren.
Außerdem kann ich z.B. auch die Getter und Setter händisch bearbeiten, um etwa Änderungszeiten zu speichern oder auf bestimmte Änderungen zu reagieren.
Wenn ich spätere Änderungen an den Strukturen vornehme wird eine neue
Unit nach obigem Muster erstellt. Diese enthält dann neue oder geänderte Regionen für neue oder geänderte Eigenschaften bzw. weniger Regionen, wenn Eigenschaften entfernt wurden.
Dann müssen die alte und die neue
Unit verglichen werden.
Dabei sollen aber nur die definierten Regionen (die in zwei Ebenen existieren) analysiert werden.
Diese Regionen werden dann in der Projektunit korrigiert.
(Sofern darin händische Änderungen vorgenommen wurden (z.B. überschriebener Setter) ist der Bereich von Hand einzupflegen.)
Dazu will ich die Regionen extrahieren und in verschachtelten Objekten abspeichern.
Die
Unit würde dann im oberen Bereich so aussehen:
Code:
TodTournamentEvent = class(TodOlympicCustom)
private
<<<PRIVAT>>>
protected
Die erste extrahierte Region so:
Code:
<<<name>>>
<<<state>>>
<<<sport>>>
<<<place>>>
...
Die weiteren Unterregionen enthalten dann den tatsächlichen Code.
Das Tool kann nun analysieren, welche Quelltextteile neu sind oder geändert wurden und daraus eine geänderte
Unit erzeugen.
Dazu werden die <<<MARKIERUNGEN>>> wieder durch den Quelltext (mit umschließender Regionen-Deklaration) ersetzt.
In dieser Form erzeuge ich auch bereits die ersten generieten Units. Das funktioniert also schon mal sehr gut.
Mein Problem ist nun, die Regionen zu finden und zu ersetzen.
Ich würde jetzt wohl Pos und PosEx etc. verwenden und "damit herum wurschteln"...
Sieht jemand eine bessere Lösung?
Die
IDE macht ja die Regionen-Analyse selbst schon perfekt und erkennt auch noch Kommentierungsbereiche. In gewisser Weise müsste ich das nachbauen.
Kann man auf irgend etwas fertiges zurück greifen?
PS: Bisher habe ich die Unterbereiche in Include-Dateien ausgelagert und diese ggf. später überschrieben. Das ist jedoch beim Debuging teilweise etwas nervig, daher möchte ich lieber auf die Regionen umstellen. Dann gäbe es auch weniger Projektdateien.
[EDIT] Im Bild sieht man, dass der automatisch generierte Code "schön im Hintergrund bleibt". Man kann ihn aber bei Bedarf in bestimmten Bereichen ändern und trotzdem später wieder Strukturänderungen vornehmen.