if name == "" {
		return ""
	}

	if ns.NameReplacer != nil {
		tmpName := ns.NameReplacer.Replace(name)

		if tmpName == "" {
			return name
		}

		name = tmpName
	}

	if ns.NoLowerCase {
		return name
	}

	var (
		value                          = commonInitialismsReplacer.Replace(name)
		buf                            strings.Builder

}

// Raw - returns the underlying data with format info.
func (r *Record) Raw() (sql.SelectObjectFormat, any) {
	return sql.SelectFmtCSV, r
}

// Replace - is not supported for CSV
func (r *Record) Replace(_ any) error {
	return errors.New("Replace is not supported for CSV")
}

// NewRecord - creates new CSV record.
func NewRecord() *Record {
	return &Record{}

                    }
                }
            }
        }
    }

    private
    fun String.urlEncodeSpace() = replace(" ", "%20")

    private
    fun String.escape() = replace("<", "&lt;").replace(">", "&gt;")
}

data class Problem(
    val name: String,
    val relativePath: String,
    val lineNumber: Int
)

     * identifier are added, then the value of the replace argument determines the behaviour.
     *
     * If replace is false, then any existing repository with the same ID will remain in use. If replace
     * is true, the new repository replaces the original.
     *

        get() = if (isKotlin) kotlinSourceFilePath else javaSourceFilePath

    private
    val JApiClass.javaSourceFilePath: String
        get() = fullyQualifiedName
            .replace(".", "/")
            .replace(innerClassesPartRegex, "") + ".java"

    private
    val innerClassesPartRegex =
        "\\$.*".toRegex()

    private
    val JApiClass.kotlinSourceFilePath: String

   * result from the user invoking {@link Cache#put}, {@link LoadingCache#refresh}, {@link Map#put},
   * {@link Map#putAll}, {@link ConcurrentMap#replace(Object, Object)}, or {@link
   * ConcurrentMap#replace(Object, Object, Object)}.
   */
  REPLACED {
    @Override
    boolean wasEvicted() {
      return false;
    }
  },

  /**

        if (value == null) {
            return "";
        }
        return value.replace("\\", "\\\\")
                .replace("\"", "\\\"")
                .replace("\b", "\\b")
                .replace("\f", "\\f")
                .replace("\n", "\\n")
                .replace("\r", "\\r")
                .replace("\t", "\\t");
    }

    private void logAsText(AuditEntry entry) {

        if (form.storageAccessKey != null && StringUtil.isNotBlank(form.storageAccessKey.replace("*", " "))) {
            fessConfig.setStorageAccessKey(form.storageAccessKey);
        }
        if (form.storageSecretKey != null && StringUtil.isNotBlank(form.storageSecretKey.replace("*", " "))) {
            fessConfig.setStorageSecretKey(form.storageSecretKey);
        }

	}
	return u.detail
}

// Msg - Replace the current error's message
func (u Err) Msg(m string) Err {
	e := u.Clone()
	e.msg = m
	return e
}

// Msgf - Replace the current error's message
func (u Err) Msgf(m string, args ...any) Err {
	e := u.Clone()
	if len(args) == 0 {
		e.msg = m
	} else {
		e.msg = fmt.Sprintf(m, args...)
	}
	return e
}

// Hint - Replace the current error's message

        }

        @Test
        @DisplayName("Should replace entry in cache map")
        void testReplaceCacheWithMap() {
            String key = "test-key";

            // Setup concrete implementation
            concreteImplementation.setKey(key);
            concreteImplementation.setCacheMap(cacheMap);

            // Execute replace
            concreteImplementation.replaceCache();