snes-disassembler/dist/analysis-cache.d.ts

A Super Nintendo (SNES) ROM disassembler for 65816 assembly

/**
 * ROM Analysis Cache System
 *
 * Reduces redundant ROM analysis calls by implementing intelligent caching
 * and streamlined validation steps while maintaining analysis integrity.
 */
import { DisassemblyLine } from './types';
import { SNESRom } from './rom-parser';
import { ValidationResult } from './validation-engine';
import { ExtractedAudioState } from './spc-state-extractor';
export interface CacheEntry {
    hash: string;
    timestamp: number;
    data: any;
    metadata: {
        romSize: number;
        cartridgeType: string;
        version: string;
    };
}
export interface AnalysisCacheConfig {
    maxCacheAge: number;
    maxCacheSize: number;
    enableMemoryCache: boolean;
    enablePersistentCache: boolean;
    cacheValidation: boolean;
}
interface CacheStats {
    hits: number;
    misses: number;
    evictions: number;
    cacheSize: number;
}
/**
 * Centralized cache for ROM analysis results to eliminate redundant calculations
 */
export declare class ROMAnalysisCache {
    private memoryCache;
    private config;
    private logger;
    private stats;
    private currentlyProcessing;
    private recursionDepth;
    private readonly MAX_RECURSION_DEPTH;
    private static readonly CACHE_KEYS;
    constructor(config?: Partial<AnalysisCacheConfig>);
    /**
     * Generate cache key based on ROM content and analysis parameters
     */
    private generateCacheKey;
    /**
     * Calculate fast hash of ROM data for cache key generation
     */
    private calculateROMHash;
    /**
     * Check if cache entry is valid and not expired
     */
    private isValidCacheEntry;
    /**
     * Check if a key is currently being processed (recursion guard)
     */
    private isCurrentlyProcessing;
    /**
     * Mark a key as currently being processed and track recursion depth
     */
    private markAsProcessing;
    /**
     * Unmark a key as currently being processed
     */
    private unmarkAsProcessing;
    /**
     * Get cached analysis result if available and valid
     */
    get<T>(rom: SNESRom, analysisType: string, params?: any): T | null;
    /**
     * Store analysis result in cache
     */
    set<T>(rom: SNESRom, analysisType: string, data: T, params?: any): void;
    /**
     * Evict oldest cache entry (LRU)
     */
    private evictOldestEntry;
    /**
     * Invalidate all cache entries for a specific ROM
     */
    invalidateROM(rom: SNESRom): void;
    /**
     * Clear all cache entries
     */
    clear(): void;
    /**
     * Get cache statistics
     */
    getStats(): CacheStats & {
        hitRate: number;
    };
    /**
     * Begin processing for a specific analysis operation (public API)
     * Returns false if recursion is detected or max depth exceeded
     */
    beginProcessing(rom: SNESRom, analysisType: string, params?: any): boolean;
    /**
     * End processing for a specific analysis operation (public API)
     */
    endProcessing(rom: SNESRom, analysisType: string, params?: any): void;
    /**
     * Check if a specific analysis operation is currently being processed
     */
    isProcessing(rom: SNESRom, analysisType: string, params?: any): boolean;
    /**
     * Get current recursion depth for a specific operation
     */
    getRecursionDepth(rom: SNESRom, analysisType: string, params?: any): number;
    /**
     * Clear all processing state (useful for cleanup after errors)
     */
    clearProcessingState(): void;
    /**
     * Convenience methods for specific analysis types
     */
    getROMInfo(rom: SNESRom): SNESRom | null;
    setROMInfo(rom: SNESRom): void;
    getVectors(rom: SNESRom): any[] | null;
    setVectors(rom: SNESRom, vectors: any[]): void;
    getBankLayout(rom: SNESRom): any[] | null;
    setBankLayout(rom: SNESRom, bankLayout: any[]): void;
    getFunctions(rom: SNESRom, params?: any): {
        functions: any[];
        data: any[];
    } | null;
    setFunctions(rom: SNESRom, functions: {
        functions: any[];
        data: any[];
    }, params?: any): void;
    getValidationResult(rom: SNESRom, params?: any): ValidationResult | null;
    setValidationResult(rom: SNESRom, result: ValidationResult, params?: any): void;
    getAudioState(rom: SNESRom): ExtractedAudioState | null;
    setAudioState(rom: SNESRom, audioState: ExtractedAudioState): void;
    getDisassembly(rom: SNESRom, params: {
        start: number;
        end: number;
    }): DisassemblyLine[] | null;
    setDisassembly(rom: SNESRom, lines: DisassemblyLine[], params: {
        start: number;
        end: number;
    }): void;
}
/**
 * Singleton cache instance for global use
 */
export declare const globalROMCache: ROMAnalysisCache;
export {};
//# sourceMappingURL=analysis-cache.d.ts.map