ProgramPool.h

Go to the documentation of this file.

 
#pragma once
 
#include <memory>
#include <thread>
#include <mutex>
#include <unordered_map>
#include <string>
#include <vector>
#include <optional>
 
#include <bpp_include/bpp.h>
#include <include/BashVersion.h>
 
class ProgramPool {
    private:
        size_t max_programs = 10; // Maximum number of programs to keep in the pool
        std::vector<std::shared_ptr<bpp::bpp_program>> programs;
        std::unordered_map<std::string, size_t> program_indices; // Maps file paths to program indices in the pool
        std::unordered_map<std::string, bool> open_files; // Maps file paths to whether they are currently open
        std::unordered_map<std::string, std::string> unsaved_changes; // Maps file paths to their unsaved contents
        BashVersion target_bash_version = {5, 2};
        std::recursive_mutex pool_mutex; // Mutex to protect access to the pool
 
        // Pool snapshots:
        struct Snapshot {
            std::vector<std::shared_ptr<bpp::bpp_program>> programs_snapshot; // Snapshot of the current programs in the pool
            std::unordered_map<std::string, size_t> program_indices_snapshot; // Snapshot of the current program indices
            std::unordered_map<std::string, bool> open_files_snapshot; // Snapshot of the current open files
            std::unordered_map<std::string, std::string> unsaved_changes_snapshot; // Snapshot of the current unsaved changes
        };
        std::unique_ptr<Snapshot> snapshot = std::make_unique<Snapshot>();
        mutable std::recursive_mutex snapshot_mutex; // Mutex to protect access to the snapshot
 
        bool utf16_mode = false; // Whether to use UTF-16 mode for character counting
 
        void _remove_oldest_program();
        void _remove_program(size_t index);
        std::shared_ptr<bpp::bpp_program> _parse_program(const std::string& file_path);
 
        // Configurable settings
        std::shared_ptr<std::vector<std::string>> include_paths = std::make_shared<std::vector<std::string>>();
        bool suppress_warnings = false;
 
        void update_snapshot();
        Snapshot load_snapshot() const;
    public:
        explicit ProgramPool(size_t max_programs = 10);
 
        void add_include_path(const std::string& path);
        void set_suppress_warnings(bool suppress);
        void set_utf16_mode(bool mode);
        bool get_utf16_mode() const;
        void set_target_bash_version(const BashVersion& version);
 
        void set_unsaved_file_contents(const std::string& file_path, const std::string& contents);
        void remove_unsaved_file_contents(const std::string& file_path);
 
        std::string get_file_contents(const std::string& file_path);
        
        std::shared_ptr<bpp::bpp_program> get_program(const std::string& file_path, bool jump_queue = false);
 
        bool has_program(const std::string& file_path);
 
        std::shared_ptr<bpp::bpp_program> re_parse_program(const std::string& file_path);
        
        void open_file(const std::string& file_path);
 
        void close_file(const std::string& file_path);
 
        void clean();
};