Rinominare le strategie con Batch Find & Replace - Analisi personalizzata

Ideale se si desidera creare rapidamente nomi puliti e informativi per un'intera banca dati, questo frammento di analisi personalizzata consente di rinominare in batch le strategie in StrategyQuant X utilizzando il semplice trova → sostituisci (o semplicemente trova → rimuovi).

- Cosa fa

• Funziona come un Analisi personalizzata (Analisi completa della banca dati).

• Argomenti in ingresso accetta find=>replace o semplicemente find per rimuovere.

• Rinomina in posizione nella banca dati sorgente selezionata.

• Letterale, sensibile alle maiuscole e alle minuscole abbinamento. Supporti \n, \t, \r.

• Ottimo per la pulizia di massa: tagliare prefissi/suffissi, rimuovere parole, standardizzare simboli/tempi/direzioni.

- Come installare

1. Editor di codice → Nuovo → Analisi personalizzata, nominare il file CARenameFindReplace
2. Incollare il codice (sotto) e Compilazione.
3. Se necessario, riavviare SQX.

- Come si usa

1. Personalizzato Project → Task → Analisi personalizzata. (Può essere eseguito anche all'interno di una banca dati da Banca dati > Strumenti > Esegui CA).
2. In Analisi completa della banca dati, selezionare CARenameFindReplace e scegliete il vostro Fonte banca dati.
3. In Argomenti in ingresso inserire una delle seguenti opzioni:
   -
   Sostituire: vecchio=>nuovo
   Rimuovere: vecchio
   -
4. Attivare l'opzione 'Filtra per risultati dell'analisi personalizzata' per rinominare le strategie originali. (Se si disattiva questa opzione, le strategie verranno duplicate e solo i duplicati verranno rinominati, lasciando inalterati gli originali).
5. Eseguire. Tutti i nomi delle strategie nella banca dati Source vengono aggiornati.

- Esempi

• Eliminare la parola "Strategia" (con lo spazio a seguire):
  Strategia =>
• Converte il nome automatico SQX in un'etichetta formattata:
  Strategia =>XAUUSD_H1_L_
• Spogliare i punti dopo un passaggio di prefisso:
  .=>

Suggerimento: Eseguire più passaggi per la formattazione in più fasi (ad esempio, aggiungere un prefisso, poi eliminare i caratteri, quindi aggiungere un suffisso). Considerare la possibilità di duplicare prima la banca dati se si desidera un facile rollback.

Codice:

pacchetto SQ.CustomAnalysis;

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

importare java.util.ArrayList;
importare 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 progetto,
            String task,
            String databankName,
            ArrayList databankRG) lancia un'eccezione {

        // Leggere la singola stringa InputArgs
        String raw = getInputArgs();
        if (raw == null) raw = "";
        raw = raw.trim();

        // Nessun argomento -> non fare nulla
        if (raw.isEmpty()) {
            return databankRG;
        }

        // Analizza: "find=>replace" OPPURE solo "find" (remove)
        Stringa find, repl;
        int arrow = raw.indexOf("=>");
        se (freccia >= 0) {
            find = raw.substring(0, arrow);
            repl = raw.substring(arrow + 2);
        } else {
            find = raw;
            repl = "";
        }

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

        // Se find è vuoto, non fare nulla (per evitare che venga rinominato accidentalmente)
        if (find.isEmpty()) {
            restituisce databankRG;
        }

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

        // Istantanea degli originali per evitare ConcurrentModificationException
        ArrayList snapshot = new ArrayList(databankRG);

        // Tenere traccia dei nomi esistenti in modo da evitare collisioni se necessario
        HashSet usedNames = new HashSet();
        for (ResultsGroup rg : snapshot) {
            if (rg.getName() := null) usedNames.add(rg.getName());
        }

        // 1) Creare cloni rinominati (senza db.add all'interno dell'iterazione)
        ArrayList clonesToAdd = new ArrayList();

        for (ResultsGroup rg : snapshot) {
            String oldName = rg.getName();
            se (oldName == null) continuare;

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

            // Duplicare solo se il nome cambia
            if (!newName.equals(oldName)) {
                // Evita le collisioni tra nomi esatti (sicurezza opzionale)
                String finalName = makeUniqueName(newName, usedNames);

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

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

        // 2) Aggiungere i cloni dopo l'iterazione (sicuro)
        for (ResultsGroup newRg : clonesToAdd) {
            db.add(newRg, true);
        }

        // Restituisce le strategie appena create (rispecchia il comportamento di SQX RenameStrategies)
        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");
    }
}