C++ Code Generator (Free AI Tool)

Plain English:
"Create a file handler class that opens a file in constructor,
automatically closes in destructor, provides read/write methods,
and uses RAII pattern with exception safety."

#include <fstream>
#include <string>
#include <stdexcept>
#include <memory>

/**
 * RAII file handler with automatic resource management.
 * 
 * Opens file in constructor, guarantees closure in destructor.
 * Provides exception-safe file operations.
 */
class FileHandler {
private:
    std::unique_ptr<std::fstream> file_;
    std::string filename_;
    
public:
    /**
     * Opens file with specified mode.
     * 
     * @param filename Path to file
     * @param mode File open mode (ios::in, ios::out, etc.)
     * @throws std::runtime_error if file cannot be opened
     */
    explicit FileHandler(const std::string& filename, 
                        std::ios::openmode mode = std::ios::in | std::ios::out)
        : file_(std::make_unique<std::fstream>(filename, mode)),
          filename_(filename) {
        
        if (!file_->is_open()) {
            throw std::runtime_error("Failed to open file: " + filename);
        }
    }
    
    // Disable copy (file handles are not copyable)
    FileHandler(const FileHandler&) = delete;
    FileHandler& operator=(const FileHandler&) = delete;
    
    // Enable move semantics
    FileHandler(FileHandler&& other) noexcept
        : file_(std::move(other.file_)),
          filename_(std::move(other.filename_)) {}
    
    FileHandler& operator=(FileHandler&& other) noexcept {
        if (this != &other) {
            file_ = std::move(other.file_);
            filename_ = std::move(other.filename_);
        }
        return *this;
    }
    
    /**
     * Destructor automatically closes file.
     * 
     * RAII guarantees cleanup even if exceptions occur.
     */
    ~FileHandler() {
        if (file_ && file_->is_open()) {
            file_->close();
        }
    }
    
    /**
     * Writes data to file.
     * 
     * @param data String to write
     * @throws std::runtime_error if write fails
     */
    void write(const std::string& data) {
        if (!file_ || !file_->is_open()) {
            throw std::runtime_error("File not open for writing");
        }
        
        *file_ << data;
        
        if (file_->fail()) {
            throw std::runtime_error("Write operation failed");
        }
    }
    
    /**
     * Reads entire file content.
     * 
     * @return File contents as string
     * @throws std::runtime_error if read fails
     */
    std::string read() {
        if (!file_ || !file_->is_open()) {
            throw std::runtime_error("File not open for reading");
        }
        
        file_->seekg(0, std::ios::beg);
        std::string content((std::istreambuf_iterator<char>(*file_)),
                           std::istreambuf_iterator<char>());
        
        if (file_->bad()) {
            throw std::runtime_error("Read operation failed");
        }
        
        return content;
    }
    
    /**
     * Gets filename.
     * 
     * @return Filename string
     */
    const std::string& filename() const noexcept {
        return filename_;
    }
};

Plain English:
"Create a generic cache template class using unordered_map,
with get, put, and size methods, LRU eviction policy,
and thread-safe operations using mutex."

#include <unordered_map>
#include <list>
#include <mutex>
#include <optional>
#include <stdexcept>

/**
 * Thread-safe LRU cache with generic key-value storage.
 * 
 * @tparam Key Type of cache keys (must be hashable)
 * @tparam Value Type of cached values
 */
template<typename Key, typename Value>
class LRUCache {
private:
    size_t capacity_;
    mutable std::mutex mutex_;
    std::list<Key> lru_list_;  // Most recent at front
    std::unordered_map<Key, std::pair<Value, typename std::list<Key>::iterator>> cache_;
    
    /**
     * Moves key to front of LRU list (most recently used).
     * 
     * @param key Key to update
     * @note Caller must hold mutex lock
     */
    void touch(const Key& key) {
        auto it = cache_.find(key);
        if (it != cache_.end()) {
            lru_list_.erase(it->second.second);
            lru_list_.push_front(key);
            it->second.second = lru_list_.begin();
        }
    }
    
public:
    /**
     * Constructs LRU cache with specified capacity.
     * 
     * @param capacity Maximum number of items to cache
     * @throws std::invalid_argument if capacity is 0
     */
    explicit LRUCache(size_t capacity) : capacity_(capacity) {
        if (capacity == 0) {
            throw std::invalid_argument("Cache capacity must be greater than 0");
        }
    }
    
    /**
     * Retrieves value from cache.
     * 
     * @param key Key to lookup
     * @return Optional containing value if found, nullopt otherwise
     * @note Thread-safe operation
     */
    std::optional<Value> get(const Key& key) {
        std::lock_guard<std::mutex> lock(mutex_);
        
        auto it = cache_.find(key);
        if (it == cache_.end()) {
            return std::nullopt;
        }
        
        touch(key);
        return it->second.first;
    }
    
    /**
     * Inserts or updates value in cache.
     * 
     * If cache is full, evicts least recently used item.
     * 
     * @param key Key to insert/update
     * @param value Value to store
     * @note Thread-safe operation
     */
    void put(const Key& key, const Value& value) {
        std::lock_guard<std::mutex> lock(mutex_);
        
        auto it = cache_.find(key);
        
        // Update existing key
        if (it != cache_.end()) {
            it->second.first = value;
            touch(key);
            return;
        }
        
        // Evict LRU if at capacity
        if (cache_.size() >= capacity_) {
            const Key& lru_key = lru_list_.back();
            cache_.erase(lru_key);
            lru_list_.pop_back();
        }
        
        // Insert new key
        lru_list_.push_front(key);
        cache_[key] = {value, lru_list_.begin()};
    }
    
    /**
     * Gets current cache size.
     * 
     * @return Number of items in cache
     * @note Thread-safe operation
     */
    size_t size() const {
        std::lock_guard<std::mutex> lock(mutex_);
        return cache_.size();
    }
    
    /**
     * Clears all items from cache.
     * 
     * @note Thread-safe operation
     */
    void clear() {
        std::lock_guard<std::mutex> lock(mutex_);
        cache_.clear();
        lru_list_.clear();
    }
};