package strings

import (
	"io"
	"sync"
)

// Replacer replaces a list of strings with replacements.
// It is safe for concurrent use by multiple goroutines.
type Replacer struct {
	once   sync.Once // guards buildOnce method
	r      replacer
	oldnew []string
}

// replacer is the interface that a replacement algorithm needs to implement.
type replacer interface {
	Replace(s string) string

// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package strings

func (r *Replacer) Replacer() any {
	r.once.Do(r.buildOnce)
	return r.r
}

func (r *Replacer) PrintTrie() string {
	r.once.Do(r.buildOnce)
	gen := r.r.(*genericReplacer)
	return gen.printNode(&gen.root, 0)
}

	UniqueName(table, column string) string
}

// Replacer replacer interface like strings.Replacer
type Replacer interface {
	Replace(name string) string
}

var _ Namer = (*NamingStrategy)(nil)

// NamingStrategy tables, columns naming strategy
type NamingStrategy struct {
	TablePrefix         string
	SingularTable       bool
	NameReplacer        Replacer
	NoLowerCase         bool
	IdentifierMaxLength int
}

// If path contains "{*}", it will be replaced with "*".
// If path contains "{**}", it will be replaced with "**".
// If the path already contained "*" or "**", they will be left as is.
func sanitizePathTemplate(path string) string {
	return replacer.Replace(path)

            }
        }

        private final TransformReplacer replacer;
        private final TransformErrorHandler errorHandler;

        public InstrumentingVisitableURLClassLoader(String name, ClassLoader parent, TransformedClassPath classPath) {
            super(name, parent, classPath);
            replacer = new TransformReplacer(classPath);
            errorHandler = new TransformErrorHandler(name);

// This will transform to name field: foo-bar becomes FOO_BAR.
func BindEnv[T Flaggable](fs *pflag.FlagSet, name, shorthand, usage string, val *T) {
	Bind(fs, name, shorthand, usage, val)
	en := strings.ToUpper(replacer.Replace(name))
	if v, f := os.LookupEnv(en); f {
		_ = fs.Set(name, v)
	}
}

// AdditionalEnv allows additional env vars to set the flag value as well.
// Unlike BindEnv, this does not do any transformations.

func oldHTMLEscape(s string) string {
	s = Replace(s, "&", "&", -1)
	s = Replace(s, "<", "&lt;", -1)
	s = Replace(s, ">", "&gt;", -1)
	s = Replace(s, `"`, "&quot;", -1)
	s = Replace(s, "'", "&apos;", -1)
	return s
}

var capitalLetters = NewReplacer("a", "A", "b", "B")

// TestReplacer tests the replacer implementations.
func TestReplacer(t *testing.T) {
	type testCase struct {

        private final TransformReplacer replacer;
        private final TransformErrorHandler errorHandler;

        InstrumentingScriptClassLoader(ScriptSource scriptSource, ClassLoader parent, TransformedClassPath classPath, HashCode implementationHash) {
            super(scriptSource, parent, classPath, implementationHash);
            replacer = new TransformReplacer(classPath);

    // We will "steal" the body of the island and replace it with a call to the
    // new function later.
    {
      YieldOp yield_op = island_op.GetYield();
      outlined_func.getBody().takeBody(island_op.getBody());

      // Replace the yield with a return
      OpBuilder replacer(yield_op);
      island_op.getBody().push_back(new Block);
      replacer.create<mlir::func::ReturnOp>(yield_op.getLoc(),

    }

    private static final byte[] loadTransformedClass(TransformedClassPath cp, String className, File original) {
        try (TransformReplacer replacer = new TransformReplacer(cp)) {
            return replacer.getInstrumentedClass(className, protectionDomain(original))
        }
    }

    private static TransformedClassPath classPath(Map<File, File> originalToTransformed) {