ich würde gerne eure Meinung wissen, vielleicht hilft mir das weiter eine Entscheidung zu treffen.
Kurz zur Erklärung:
Ich habe mehrere verschiedene Versionen eines Scriptes.
Als Angabe kann beispielsweise kommen: "FileA Schema Mexico", ein anderer schickt mir "FileA Schema Austria", usw.
Das FileA ist binär und das jeweilige Schema/Schablone ist kann für jedes Land anders sein. Nun nehme ich mir die Datei "FileA" her und lege die angeforderte Schablone darüber und retouniere die enstandenen Records.

Nun meine Frage: Ist es sinnvoll so etwas mittels SVN zu realisieren, oder zahlt es sich für so etwas aus eine eigene Art von Repository zu erstellen/anzulegen?

Lg _freeze_

Man selber kann natürlich auch eine Versionierung in C++ implementieren. Man könnte es selber machen, wenn die Funktionalität sich hauptsächlich auf "Versionieren" beschränkt. Das ist ja erstmal etwas ganz triviales. Sobald man aber versucht was ausgefuchstes zu entwickeln, würde ich immer versuchen, etwas zu benutzen, was andere schon (besser) gemacht haben. Außer man will SVN Konkurrenz machen, dann muß man natürlich selber was entwickeln. Das willst du aber nicht.

SVN kann man also empfehlen, wenn man SVN-Feature nutzen will, bevor man das ganze eh nachbaut.

Hem, also ich habe an deinem Szenario jetzt nicht wirklich verstanden, was du machen willst

Also ich habe einen Server, der nichts anderes macht als Dateien lesen und diese für den Empfänger aufzubereiten. Die Schemas/Schablonen sind in etwas denen einer C Struktur ähnlich, nur nicht kompiliert sondern dynamisch. Sieht in etws so aus:

Austria:
--------
header:240:char
id:4:integer
dummy:100:char

Mexico:
-------
header:200:char
id:4:integer
dummy:140:char

Hier als Beispiel habe ich falls die Anfrage kommt "FileA Schema Mexico" das er die Datei hernimmt, die Bytes (Beispiel für Header 200 Char's) reinstopft und diese dann zurückgibt.

Da aber beide Schemas vom Prinzip her gleich sind dachte ich mir sowas in Richtung SVN würde mich schneller an mein Ziel bringen. Zu den Schemas kann es natürlich passieren, das ich alte Schemas auch haben kann weil halt die neuen Programme die neue "verbesserte" struktur nehmen zum schreiben. Beispiel:

Mexico NEU:
-----------
header:200:char
id:4:integer
dummy:140:char

Mexico ALT:
-----------
header:200:char
id:4:integer
dummy_header:60:char
dummy_data:60:char
dummy:20:char

Hoffe ich habe es jetzt verständlicher rüber gebracht.

Lg _freeze_

Ich würde das so angenen:

Du programmierst mehrere Klassen die je ein Schema implementieren ("Exporter" oder "Formatter"). Dazu noch eine Factory, welche die "Exporter" nach
Schema-Namen bzw. -ID kennt. Dann kannst du einfach von der Factory einen "Exporter" für z.B. Schema "Mexico NEU" anfordern, und dieses Objekt verwenden um die Daten für eine bestimmte Anfrage zu formatieren.

Natürlich kannst du auch mehrere Schematas in einer einzigen Exporter-Klasse implementieren, z.B. wenn die Unterschiede so gering sind dass sich eine eigene Klasse nicht auszahlt. Etwa wenn sich nur die Länge verschiedener Strings unterscheidet o.ä. Der Konstruktor so eines parametrisierbaren Exporters müsste dann eben Parameter nehmen die festlegen wie das Schema genau aussieht. Das hätte vor allem dann Vorteile wenn es sehr sehr viele verschiedene Schemata gibt.

Wenn sich die verwendeten Schemata selten genug ändern (und wenig genug sind) reicht das so denke ich vollends auf.

Falls Änderungen/Ergänzungen an den Schemata "hot" möglich sein sollen (=ohne z.B. ein laufendes Programm neu zu starten oder auch nur auszutauschen) wäre es wohl angebracht ein Plugin-System mit dynamisch geladenem Code zu verwenden (DLLs/SOs) und/oder stark parametrisierbare Exporter zu verwenden.

p.S.: oder willst du etwa SVN einsetzen um alle verschiedenen Versionen von File a in einem Subversion Repository abzulegen? Wenn ja, was für Vorteile erwartest du dir davon?

Nach der momentanen Abbildung haben wir ca. 50 Schematas. Ich wollte folgendes erreichen:
1.) Schematas im Filesystem (pro Schemata/File oder so) abzulegen
2.) Versionshinweise bzw. Kommentare für die verschiedenen Versionen
3.) So minimal als nötig
4.) Kein DB Backend

Aber ich glaube von dem Reden ist mir selbst gerade ein Licht aufgegangen.

Ich erstelle eine "schematas.xml" in der kommentare, versionen usw. drin stehen inkl. dateinamen des schematas. Und dann halt pro Schemata eine Datei (Bsp. aut00001.shm, mex00001.shm, mex00002.shm, usw.)
Beim Anwenden eines Schemas wird die jeweilige Datei geladen, geparst (Datentype, Feldgröße, usw.) danach über die Binärdaten darübergelegt. Und das wars.

Hoffe es wird wirklich so einfach wie gerade geschrieben

Was hältst du davon?

Lg _freeze_

Und ja, das könnte so funktionieren.
Wenn eine Sprache wie Python verwendet wird kannst du die aber u.U. auch das ganze Datei-Parsen sparen, und die Schemata gleich als Python Code ablegen.

Warum SVN? Weil wenn es für SVN sinn gemacht hätte, hätte ich nicht das Rad neu erfinden müssen.

oh. aber warum dann nicht zb paint oder notepad? damit gehts bestimmt genausogut.