Umbenennungsstrategien mit Stapelsuchen und Ersetzen - Benutzerdefinierte Analyse

Ideal, wenn Sie schnell saubere, aussagekräftige Namen für eine ganze Datenbank erstellen möchten - mit diesem benutzerdefinierten Analyse-Snippet können Sie Strategien in StrategyQuant X mit einfachem Suchen → Ersetzen (oder einfach Suchen → Entfernen) stapelweise umbenennen.

- Was es bewirkt

• Läuft als Benutzerdefinierte Analyse (Vollständige Datenbankanalyse).

• Eingabe-Argumente akzeptiert find=>replace oder einfach find zu entfernen.

• Benennt um. an Ort und Stelle in der ausgewählten Quelldatenbank.

• Wörtlich, Groß- und Kleinschreibung übereinstimmen. Unterstützt \n, \t, \r.

• Hervorragend geeignet für die Massenbereinigung: Präfixe/Suffixe kürzen, Wörter entfernen, Symbole/Zeitrahmen/Richtungen vereinheitlichen.

- Wie installieren?

1. Code-Editor → Neu → Benutzerdefinierte Analysebenennen Sie die Datei CARenameFindReplace
2. Fügen Sie den Code (unten) ein und Kompilieren.
3. Starten Sie bei Bedarf SQX neu.

- Wie zu verwenden

1. Benutzerdefiniert Project → Aufgabe → Benutzerdefinierte Analyse. (Kann auch innerhalb einer Datenbank über Datenbank > Werkzeuge > CA ausführen ausgeführt werden).
2. Unter Vollständige Datenbankanalyseauswählen CARenameFindReplace und wählen Sie Ihre Quelle datenbank.
3. Unter Eingabe-Argumente eine der folgenden Angaben machen:
   -
   Ersetzen: Alt=>Neu
   Entfernen: alt
   -
4. Aktivieren Sie 'Nach Ergebnissen der benutzerdefinierten Analyse filtern', um die Originalstrategien umzubenennen. (Wenn Sie dies deaktivieren, werden die Strategien dupliziert und nur die Duplikate umbenannt, während die Originale unangetastet bleiben).
5. Ausführen. Alle Strategienamen in der Quellendatenbank werden aktualisiert.

- Beispiele

• Entfernen Sie das Wort "Strategie" (mit nachgestelltem Leerzeichen):
  Strategie =>
• SQX-Autoname in eine formatierte Bezeichnung umwandeln:
  Strategie =>XAUUSD_H1_L_
• Punkte nach einem Präfixdurchgang entfernen:
  .=>

Tipp: Führen Sie mehrere Durchgänge für eine mehrstufige Formatierung durch (z. B. Hinzufügen eines Präfixes, dann Entfernen von Zeichen, dann Hinzufügen eines Suffixes). Erwägen Sie, die Datenbank zunächst zu duplizieren, wenn Sie ein einfaches Rollback wünschen.

Code:

Paket SQ.CustomAnalysis;

import com.strategyquant.tradinglib.*;
import com.strategyquant.tradinglib.project.ProjectEngine;
import com.strategyquant.tradinglib.project.SQProject;

import java.util.ArrayList;
import java.util.HashSet;

public class CARenameFindReplace extends CustomAnalysisMethod {

    public CARenameFindReplace() {
        super("CARenameFindReplace", TYPE_PROCESS_DATABANK);
    }

    @Override
    public boolean filterStrategy(String project, String task, String databankName, ResultsGroup rg) throws Exception {
        return true;
    }

    @Override
    public ArrayList processDatabank(
            String Projekt,
            String Aufgabe,
            String databankName,
            ArrayList databankRG) throws Exception {

        // Einzelne Eingabe-Args-String lesen
        String raw = getInputArgs();
        if (raw == null) raw = "";
        raw = raw.trim();

        // Keine Eingaben -> nichts tun
        if (raw.isEmpty()) {
            return databankRG;
        }

        // Parsen: "find=>replace" ODER nur "find" (entfernen)
        String find, repl;
        int arrow = raw.indexOf("=>");
        if (arrow >= 0) {
            find = raw.substring(0, arrow);
            repl = raw.substring(arrow + 2);
        } sonst {
            find = raw;
            repl = "";
        }

        find = unescape(find);
        repl = unescape(repl);

        // Wenn find leer ist, nichts tun (verhindert versehentliches Umbenennen)
        if (find.isEmpty()) {
            return databankRG;
        }

        SQProject prj = ProjectEngine.get(project);
        Datenbank db = prj.getDatabanks().get(databankName);

        // Snapshot der Originale zur Vermeidung von ConcurrentModificationException
        ArrayList snapshot = new ArrayList(databankRG);

        // Vorhandene Namen verfolgen, um ggf. Kollisionen zu vermeiden
        HashSet usedNames = new HashSet();
        for (ResultsGroup rg : snapshot) {
            if (rg.getName() != null) usedNames.add(rg.getName());
        }

        // 1) Umbenannte Klone erstellen (kein db.add innerhalb der Iteration)
        ArrayList clonesToAdd = new ArrayList();

        for (ErgebnisGruppe rg : snapshot) {
            String oldName = rg.getName();
            if (oldName == null) continue;

            String newName = oldName.replace(find, repl);

            // Nur duplizieren, wenn sich der Name ändert
            if (!newName.equals(oldName)) {
                // Kollisionen mit exakten Namen vermeiden (optionale Sicherheit)
                String finalName = makeUniqueName(newName, usedNames);

                ResultsGroup newRg = rg.clone();
                newRg.setName(finalName);

                clonesToAdd.add(newRg);
                usedNames.add(finalName);
            }
        }

        // 2) Klone nach Iteration hinzufügen (sicher)
        for (ErgebnisGruppe newRg : clonesToAdd) {
            db.add(newRg, true);
        }

        // Rückgabe der neu erstellten Strategien (spiegelt das Verhalten von SQX RenameStrategies wider)
        return clonesToAdd;
    }

    private static String makeUniqueName(String baseName, HashSet used) {
        if (!used.contains(baseName)) return baseName;

        int i = 2;
        while (true) {
            String candidate = baseName + "_" + i;
            if (!used.contains(candidate)) return candidate;
            i++;
        }
    }

    private static String unescape(String s) {
        if (s == null) return "";
        return s.replace("\\n", "\n")
                .replace("\\t", "\t")
                .replace("\\r", "\r");
    }
}