Estratégias de renomeação com localização e substituição em lote - Análise personalizada

Ideal se você quiser criar rapidamente nomes limpos e informativos em um banco de dados inteiro, esse snippet do Custom Analysis permite renomear em lote as estratégias no StrategyQuant X usando simplesmente localizar → substituir (ou apenas localizar → remover).

- O que ele faz

• Funciona como um Análise personalizada (Análise completa do banco de dados).

• Args de entrada aceita find=>replace ou apenas find para remover.

• Renomeia no local no banco de dados de origem selecionado.

• Literal, sensível a maiúsculas e minúsculas Combinação. Suporte \n, \t, \r.

• Ótimo para limpeza em massa: corte prefixos/sufixos, remova palavras, padronize símbolos/tempos/direções.

- Como instalar

1. Code Editor → New → Custom Analysis, nomeie o arquivo CARenameFindReplace
2. Cole o código (abaixo) e Compilação.
3. Se necessário, reinicie o SQX.

- Como usar

1. Personalizado Project → Task → Análise personalizada. (Também pode ser executado dentro de um banco de dados em Banco de dados > Ferramentas > Executar CA).
2. Em Análise completa do banco de dadosselecione CARenameFindReplace e escolha seu Fonte banco de dados.
3. Em Args de entrada insira uma das opções:
   -
   Substituir: antigo=>novo
   Remover: antigo
   -
4. Ative a opção 'Filtrar por resultados de análise personalizada' para renomear as estratégias originais. (Se você desativar essa opção, as estratégias serão duplicadas e somente as duplicadas serão renomeadas, deixando as originais intocadas).
5. Executar. Todos os nomes de estratégias no banco de dados Source são atualizados.

- Exemplos

• Remova a palavra "Strategy" (com espaço à direita):
  Estratégia =>
• Converte o nome automático SQX em um rótulo formatado:
  Estratégia =>XAUUSD_H1_L_
• Retire os pontos após uma passagem de prefixo:
  .=>

Dica: Execute várias passagens para formatação em várias etapas (por exemplo, adicionar um prefixo, depois remover caracteres e, em seguida, adicionar um sufixo). Considere a possibilidade de duplicar o banco de dados primeiro se quiser uma reversão fácil.

Código:

pacote SQ.CustomAnalysis;

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

Importar 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
    público ArrayList processDatabank(
            String project,
            String task,
            String databankName,
            ArrayList databankRG) throws Exception {

        // Ler uma única string de args de entrada
        String raw = getInputArgs();
        Se (raw == null) raw = "";
        raw = raw.trim();

        // Sem args -> não fazer nada
        Se (raw.isEmpty()) {
            return databankRG;
        }

        // Analisar: "find=>replace" OU apenas "find" (remover)
        String find, repl;
        int seta = raw.indexOf("=>");
        se (seta >= 0) {
            find = raw.substring(0, arrow);
            repl = raw.substring(arrow + 2);
        } else {
            find = raw;
            repl = "";
        }

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

        // Se find estiver vazio, não faça nada (evita renomear tudo acidentalmente)
        se (find.isEmpty()) {
            return databankRG;
        }

        SQProject prj = ProjectEngine.get(project);
        Banco de dados db = prj.getDatabanks().get(databankName);

        // Instantâneo dos originais para evitar ConcurrentModificationException
        ArrayList snapshot = novo ArrayList(databankRG);

        // Rastrear os nomes existentes para que possamos evitar colisões, se necessário
        HashSet usedNames = new HashSet();
        para (ResultsGroup rg : snapshot) {
            if (rg.getName() != null) usedNames.add(rg.getName());
        }

        // 1) Criar clones renomeados (sem db.add dentro da iteração)
        ArrayList clonesToAdd = new ArrayList();

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

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

            // Duplicar somente se o nome for alterado
            se (!newName.equals(oldName)) {
                // Evitar colisões de nomes exatos (segurança opcional)
                String finalName = makeUniqueName(newName, usedNames);

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

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

        // 2) Adicionar clones após a iteração (seguro)
        for (ResultsGroup newRg : clonesToAdd) {
            db.add(newRg, true);
        }

        // Retornar as estratégias recém-criadas (espelha o comportamento 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;
            se (!used.contains(candidate)) retorna candidate;
            i++;
        }
    }

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