Estrategias de cambio de nombre con Batch Find & Replace - Análisis personalizado

Este fragmento de análisis personalizado es ideal si desea crear rápidamente nombres claros e informativos para toda una base de datos, ya que le permite renombrar estrategias por lotes en StrategyQuant X mediante la sencilla función buscar → reemplazar (o simplemente buscar → eliminar).

- Para qué sirve

• Funciona como Análisis personalizado (Análisis completo del banco de datos).

• Argumentos de entrada acepta find=>replace o simplemente find para eliminar.

• Cambia el nombre de en su sitio en el banco de datos Fuente seleccionado.

• Literal, distingue entre mayúsculas y minúsculas partido. Admite \n, t, r.

• Ideal para la limpieza masiva: recortar prefijos/sufijos, eliminar palabras, normalizar símbolos/plazos/direcciones.

- Cómo instalar

1. Editor de código → Nuevo → Análisis personalizadonombre del archivo CARenameFindReplace
2. Pega el código (abajo) y Compile.
3. Si es necesario, reinicie SQX.

- Cómo utilizarlo

1. Personalizado Project → Tarea → Análisis personalizado. (También se puede ejecutar dentro de un banco de datos desde Banco de datos > Herramientas > Ejecutar CA).
2. En Análisis completo de la base de datosseleccione CARenameFindReplace y elija su Fuente banco de datos.
3. En Argumentos de entrada introduzca uno de:
   -
   Sustituir: antiguo=>nuevo
   Eliminar: antiguo
   -
4. Active 'Filtrar por resultados de análisis personalizados' para renombrar las estrategias originales. (Si lo desactiva, las estrategias se duplicarán y solo se renombrarán los duplicados, dejando intactos los originales).
5. Ejecutar. Se actualizan todos los nombres de estrategias de la base de datos Fuente.

- Ejemplos

• Suprima la palabra "Estrategia " (con espacio al final):
  Estrategia =>
• Convierte el nombre automático SQX en una etiqueta formateada:
  Estrategia =>XAUUSD_H1_L_
• Eliminar los puntos después de una pasada de prefijo:
  .=>

Consejo: Ejecute varias pasadas para formatear en varios pasos (por ejemplo, añada un prefijo, luego elimine caracteres, luego añada un sufijo). Considere la posibilidad de duplicar primero el banco de datos si desea deshacerlo fácilmente.

Código:

paquete 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 procesarBancoDeDatos(
            String proyecto,
            String tarea,
            String databankName,
            ArrayList databankRG) lanza Excepción {

        // Leer una única cadena InputArgs
        String raw = getInputArgs();
        if (raw == null) raw = "";
        raw = raw.trim();

        // Sin argumentos -> no hacer nada
        if (raw.isEmpty()) {
            return databankRG;
        }

        // Parse: "find=>replace" O simplemente "find" (eliminar)
        Cadena find, repl;
        int flecha = raw.indexOf("=>");
        if (flecha >= 0) {
            find = raw.substring(0, flecha);
            repl = raw.substring(flecha + 2);
        } else {
            find = raw;
            repl = "";
        }

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

        // Si find está vacío, no hacer nada (previene un renombrado accidental)
        if (find.isEmpty()) {
            return databankRG;
        }

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

        // Instantánea de los originales para evitar ConcurrentModificationException
        ArrayList snapshot = new ArrayList(databankRG);

        // Rastrear los nombres existentes para evitar colisiones si es necesario
        HashSet usedNames = new HashSet();
        for (ResultsGroup rg : snapshot) {
            if (rg.getName() != null) usedNames.add(rg.getName());
        }

        // 1) Crear clones renombrados (sin db.add dentro de la iteración)
        ArrayList clonesToAdd = new ArrayList();

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

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

            // Sólo duplicar si cambia el nombre
            if (!newName.equals(oldName)) {
                // Evitar colisiones de nombres exactos (seguridad opcional)
                String finalName = makeUniqueName(newName, usedNames);

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

                clonesToAdd.add(nuevoRg);
                usedNames.add(nombrefinal);
            }
        }

        // 2) Añadir clones después de la iteración (seguro)
        for (ResultsGroup newRg : clonesToAdd) {
            db.add(newRg, true);
        }

        // Devuelve las estrategias recién creadas (refleja el comportamiento de SQX RenameStrategies)
        return clonesToAdd;
    }

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

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

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