Hromadné přejmenování strategií

Ideální, pokud chcete rychle vytvořit přehledné a informativní názvy v celé databance – tento Custom Analysis snippet vám umožní hromadně přejmenovávat strategie ve StrategyQuant X pomocí jednoduchého najít → nahradit (nebo jen najít → odstranit).

— Co to dělá

• Spouští se jako Custom Analysis (Full databank analysis).

• Input args přijímá find=>replace or just find to remove.

• Přejmenuje položky přímo na místě ve vybrané zdrojové databance.

• Doslovná shoda s rozlišováním velkých a malých písmen. Podporuje \n, \t, \r.

• Skvělé pro hromadný úklid: oříznutí předpon/přípon, odstranění slov, standardizace symbolů/časových rámců/směrů.

— Jak nainstalovat

1. Code Editor → New → Custom Analysis, pojmenujte soubor CARenameFindReplace
2. Vložte kód (níže) a klikněte na Compile.
3. V případě potřeby restartujte SQX.

— Jak používat

1. Custom Project → Task → Custom Analysis. (Lze také spustit uvnitř databanky z Databank > Tools > Run CA).
2. V Full databank analysis vyberte CARenameFindReplace a zvolte svou Source databanku.
3. Do pole Input args zadejte jednu z možností:
   -
   Replace: old=>new
   Remove: old
   -
4. Povolte možnost „Filter by results of custom analysis“ pro přejmenování původních strategií. (Pokud tuto možnost zakážete, strategie budou duplikovány a přejmenovány budou pouze duplikáty, přičemž originály zůstanou beze změny.)
5. Spusťte proces. Všechny názvy strategií ve zdrojové databance (Source databank) budou aktualizovány.

— Příklady

• Odebrání slova „Strategy “ (včetně koncové mezery):
  Strategy =>
• Převod automatického názvu SQX na formátovaný popisek:
  Strategy =>XAUUSD_H1_L_
• Odstranění teček po přidání předpony:
  .=>

Tip: Pro vícekrokové formátování spusťte několik průchodů (např. přidejte předponu, poté odstraňte znaky a následně přidejte příponu). Pokud chcete mít možnost snadného vrácení změn, zvažte nejprve duplikování databanky.

Kód:

package 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 project,
            String task,
            String databankName,
            ArrayList databankRG) throws Exception {
        // Read single Input args string
        String raw = getInputArgs();
        if (raw == null) raw = "";
        raw = raw.trim();
        // No args -> do nothing
        if (raw.isEmpty()) {
            return databankRG;
        }
        // Parse: "find=>replace" OR just "find" (remove)
        String find, repl;
        int arrow = raw.indexOf("=>");
        if (arrow >= 0) {
            find = raw.substring(0, arrow);
            repl = raw.substring(arrow + 2);
        } else {
            find = raw;
            repl = "";
        }
        find = unescape(find);
        repl = unescape(repl);
        // If find is empty, do nothing (prevents accidental rename-all)
        if (find.isEmpty()) {
            return databankRG;
        }
        SQProject prj = ProjectEngine.get(project);
        Databank db = prj.getDatabanks().get(databankName);
        // Snapshot of originals to avoid ConcurrentModificationException
        ArrayList snapshot = new ArrayList<>(databankRG);
        // Track existing names so we can avoid collisions if needed
        HashSet usedNames = new HashSet<>();
        for (ResultsGroup rg : snapshot) {
            if (rg.getName() != null) usedNames.add(rg.getName());
        }
        // 1) Create renamed clones (no db.add inside the iteration)
        ArrayList clonesToAdd = new ArrayList<>();
        for (ResultsGroup rg : snapshot) {
            String oldName = rg.getName();
            if (oldName == null) continue;
            String newName = oldName.replace(find, repl);
            // Only duplicate if name changes
            if (!newName.equals(oldName)) {
                // Avoid exact-name collisions (optional safety)
                String finalName = makeUniqueName(newName, usedNames);
                ResultsGroup newRg = rg.clone();
                newRg.setName(finalName);
                clonesToAdd.add(newRg);
                usedNames.add(finalName);
            }
        }
        // 2) Add clones after iteration (safe)
        for (ResultsGroup newRg : clonesToAdd) {
            db.add(newRg, true);
        }
        // Return the newly created strategies (mirrors SQX RenameStrategies behaviour)
        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");
    }
}