#include <WorkspaceManager.h>

Public Member Functions
	WorkspaceManager ()

	~WorkspaceManager ()

bool	IsPortableMode () const

bool	IsFirstRun () const

bool	Initialize ()

bool	CopyResources (const std::string &installationPath)

bool	IsInitialized () const

void	SetWorkspacePath (const std::string &path)

std::string	GetWorkspacePath () const

std::string	GetStudiesPath () const

std::string	GetSnapshotsPath () const

std::string	GetChainsPath () const

std::string	GetScalesPath () const

std::string	GetDocsPath () const

std::string	GetDemoPath () const

std::string	GetTutorialPath () const

std::vector< std::string >	GetStudyDirectories () const

std::vector< std::string >	GetSnapshotDirectories () const

bool	CreateStudyDirectory (const std::string &studyName)

bool	CreateSnapshot (const std::string &studyPath, const std::string &snapshotName)

bool	ImportSnapshot (const std::string &snapshotPath, const std::string &newStudyName)

Detailed Description

Definition at line 17 of file WorkspaceManager.h.

Constructor & Destructor Documentation

◆ WorkspaceManager()

WorkspaceManager::WorkspaceManager ( )

Definition at line 37 of file WorkspaceManager.cpp.

    : mInitialized(false)
{
    // In portable mode, use current directory; otherwise use Documents
    if (IsPortableMode()) {
        mWorkspacePath = GetPortableWorkspacePath();
    } else {
        mWorkspacePath = GetDocumentsPath() + "/pebl-exp." + PEBL_VERSION;
    }
}

References IsPortableMode(), and PEBL_VERSION.

◆ ~WorkspaceManager()

WorkspaceManager::~WorkspaceManager ( )

Definition at line 48 of file WorkspaceManager.cpp.

48 {

49}

Member Function Documentation

◆ CopyResources()

bool WorkspaceManager::CopyResources ( const std::string & installationPath )

Definition at line 176 of file WorkspaceManager.cpp.

                                                                      {
    if (installationPath.empty() || IsPortableMode()) {
        std::cout << "CopyResources: skipped (empty path or portable mode)" << std::endl;
        return false;
    }
 
    std::cout << "CopyResources: installation path = " << installationPath << std::endl;
    std::cout << "CopyResources: workspace path = " << mWorkspacePath << std::endl;
 
    // Copy specific documentation files
    std::string docDest = mWorkspacePath + "/doc";
    CreateDir(docDest);
 
    std::vector<std::string> docFiles = {
        std::string("doc/pman/PEBLManual") + PEBL_VERSION + ".pdf",
        "doc/ReleaseNotes.txt",
        "Notes_for_LLMs.txt"
    };
 
    std::cout << "Copying documentation files..." << std::endl;
    for (const auto& relPath : docFiles) {
        std::string srcFile = installationPath + "/" + relPath;
        // Flatten the structure - put all files directly in doc/
        std::string filename = relPath;
        size_t lastSlash = filename.find_last_of('/');
        if (lastSlash != std::string::npos) {
            filename = filename.substr(lastSlash + 1);
        }
        std::string destFile = docDest + "/" + filename;
 
        if (CopyFileContents(srcFile, destFile)) {
            std::cout << "  ✓ Copied " << filename << std::endl;
        } else {
            std::cout << "  ✗ Failed to copy " << relPath << std::endl;
        }
    }
 
    // Copy demos (entire directory, excluding tests subdirectory)
    std::string demoSource = installationPath + "/demo";
    std::string demoDest = mWorkspacePath + "/demo";
    std::cout << "Checking for demo: " << demoSource << std::endl;
    if (DirectoryExists(demoSource)) {
        std::cout << "Copying demos from " << demoSource << " to " << demoDest << " (excluding tests/)" << std::endl;
        std::vector<std::string> excludeDirs = {"tests"};
        if (CopyDirectory(demoSource, demoDest, false, excludeDirs)) {
            std::cout << "  ✓ Demos copied successfully" << std::endl;
        } else {
            std::cout << "  ✗ Failed to copy demos" << std::endl;
        }
    } else {
        std::cout << "  Demo source not found" << std::endl;
    }
 
    // Copy tutorials (entire directory)
    std::string tutorialSource = installationPath + "/tutorials";
    std::string tutorialDest = mWorkspacePath + "/tutorials";
    std::cout << "Checking for tutorials: " << tutorialSource << std::endl;
    if (DirectoryExists(tutorialSource)) {
        std::cout << "Copying tutorials from " << tutorialSource << " to " << tutorialDest << std::endl;
        if (CopyDirectory(tutorialSource, tutorialDest, false)) {
            std::cout << "  ✓ Tutorials copied successfully" << std::endl;
        } else {
            std::cout << "  ✗ Failed to copy tutorials" << std::endl;
        }
    } else {
        std::cout << "  Tutorials source not found" << std::endl;
    }
 
    return true;
}

References IsPortableMode(), and PEBL_VERSION.

◆ CreateSnapshot()

bool WorkspaceManager::CreateSnapshot	(	const std::string &	studyPath,
		const std::string &	snapshotName
	)

Definition at line 325 of file WorkspaceManager.cpp.

                                                                                               {
    std::string snapshotPath = GetSnapshotsPath() + "/" + snapshotName;
 
    if (DirectoryExists(snapshotPath)) {
        return false;  // Already exists
    }
 
    // Copy study directory, excluding data/ subdirectories
    return CopyDirectory(studyPath, snapshotPath, true);
}

References GetSnapshotsPath().

◆ CreateStudyDirectory()

bool WorkspaceManager::CreateStudyDirectory ( const std::string & studyName )

Definition at line 305 of file WorkspaceManager.cpp.

                                                                      {
    std::string studyPath = GetStudiesPath() + "/" + studyName;
 
    if (DirectoryExists(studyPath)) {
        return false;  // Already exists
    }
 
    // Create study directory
    if (!CreateDir(studyPath)) {
        return false;
    }
 
    // Create subdirectories
    CreateDir(studyPath + "/chains");
    CreateDir(studyPath + "/tests");
    CreateDir(studyPath + "/data");
 
    return true;
}

References GetStudiesPath().

◆ GetChainsPath()

std::string WorkspaceManager::GetChainsPath ( ) const

inline

Definition at line 44 of file WorkspaceManager.h.

44{ return mWorkspacePath + "/chains"; }

◆ GetDemoPath()

std::string WorkspaceManager::GetDemoPath ( ) const

inline

Definition at line 47 of file WorkspaceManager.h.

47{ return mWorkspacePath + "/demo"; }

◆ GetDocsPath()

std::string WorkspaceManager::GetDocsPath ( ) const

inline

Definition at line 46 of file WorkspaceManager.h.

46{ return mWorkspacePath + "/doc"; }

◆ GetScalesPath()

std::string WorkspaceManager::GetScalesPath ( ) const

inline

Definition at line 45 of file WorkspaceManager.h.

45{ return mWorkspacePath + "/scales"; }

◆ GetSnapshotDirectories()

std::vector< std::string > WorkspaceManager::GetSnapshotDirectories ( ) const

Definition at line 278 of file WorkspaceManager.cpp.

                                                                    {
    std::vector<std::string> snapshots;
    std::string snapshotsPath = GetSnapshotsPath();
 
    try {
        for (const auto& entry : fs::directory_iterator(snapshotsPath)) {
            if (!entry.is_directory()) {
                continue;
            }
 
            std::string dirName = entry.path().filename().string();
            std::string fullPath = entry.path().string();
 
            // Check if directory contains study-info.json
            std::string studyInfoPath = fullPath + "/study-info.json";
            struct stat fileInfo;
            if (stat(studyInfoPath.c_str(), &fileInfo) == 0) {
                snapshots.push_back(dirName);
            }
        }
    } catch (const fs::filesystem_error&) {
        // Directory doesn't exist or can't be read
    }
 
    return snapshots;
}

References GetSnapshotsPath().

◆ GetSnapshotsPath()

std::string WorkspaceManager::GetSnapshotsPath ( ) const

inline

Definition at line 43 of file WorkspaceManager.h.

43{ return mWorkspacePath + "/snapshots"; }

Referenced by CreateSnapshot(), and GetSnapshotDirectories().

◆ GetStudiesPath()

std::string WorkspaceManager::GetStudiesPath ( ) const

inline

Definition at line 42 of file WorkspaceManager.h.

42{ return mWorkspacePath + "/my_studies"; }

Referenced by CreateStudyDirectory(), GetStudyDirectories(), and ImportSnapshot().

◆ GetStudyDirectories()

std::vector< std::string > WorkspaceManager::GetStudyDirectories ( ) const

Definition at line 251 of file WorkspaceManager.cpp.

                                                                 {
    std::vector<std::string> studies;
    std::string studiesPath = GetStudiesPath();
 
    try {
        for (const auto& entry : fs::directory_iterator(studiesPath)) {
            if (!entry.is_directory()) {
                continue;
            }
 
            std::string dirName = entry.path().filename().string();
            std::string fullPath = entry.path().string();
 
            // Check if directory contains study-info.json
            std::string studyInfoPath = fullPath + "/study-info.json";
            struct stat fileInfo;
            if (stat(studyInfoPath.c_str(), &fileInfo) == 0) {
                studies.push_back(dirName);
            }
        }
    } catch (const fs::filesystem_error&) {
        // Directory doesn't exist or can't be read
    }
 
    return studies;
}

References GetStudiesPath().

◆ GetTutorialPath()

std::string WorkspaceManager::GetTutorialPath ( ) const

inline

Definition at line 48 of file WorkspaceManager.h.

48{ return mWorkspacePath + "/tutorial"; }

◆ GetWorkspacePath()

std::string WorkspaceManager::GetWorkspacePath ( ) const

inline

Definition at line 41 of file WorkspaceManager.h.

41{ return mWorkspacePath; }

◆ ImportSnapshot()

bool WorkspaceManager::ImportSnapshot	(	const std::string &	snapshotPath,
		const std::string &	newStudyName
	)

Definition at line 336 of file WorkspaceManager.cpp.

                                                                                                  {
    std::string studyPath = GetStudiesPath() + "/" + newStudyName;
 
    if (DirectoryExists(studyPath)) {
        return false;  // Already exists
    }
 
    // Copy snapshot directory (includes everything since snapshots don't have data/)
    return CopyDirectory(snapshotPath, studyPath, false);
}

References GetStudiesPath().

◆ Initialize()

bool WorkspaceManager::Initialize ( )

Definition at line 138 of file WorkspaceManager.cpp.

                                  {
    // Skip workspace creation in portable mode
    if (IsPortableMode()) {
        mInitialized = true;
        return true;
    }
 
    // Create main workspace directory
    if (!DirectoryExists(mWorkspacePath)) {
        if (!CreateDir(mWorkspacePath)) {
            return false;
        }
    }
 
    // Create subdirectories
    std::vector<std::string> subdirs = {
        "/my_studies",
        "/snapshots",
        "/scales",
        "/doc",
        "/demo",
        "/tutorials",
        "/logs"
    };
 
    for (const auto& subdir : subdirs) {
        std::string fullPath = mWorkspacePath + subdir;
        if (!DirectoryExists(fullPath)) {
            if (!CreateDir(fullPath)) {
                return false;
            }
        }
    }
 
    mInitialized = true;
    return true;
}

References IsPortableMode().

◆ IsFirstRun()

bool WorkspaceManager::IsFirstRun ( ) const

Definition at line 122 of file WorkspaceManager.cpp.

                                        {
    // In portable mode, workspace always "exists" (current directory)
    if (IsPortableMode()) {
        return false;
    }
 
    // Check if workspace directory exists and has content
    if (!DirectoryExists(mWorkspacePath)) {
        return true;
    }
 
    // Check if my_studies exists (primary indicator)
    std::string studiesPath = mWorkspacePath + "/my_studies";
    return !DirectoryExists(studiesPath);
}

References IsPortableMode().

◆ IsInitialized()

bool WorkspaceManager::IsInitialized ( ) const

Definition at line 247 of file WorkspaceManager.cpp.

                                           {
    return mInitialized || DirectoryExists(mWorkspacePath);
}

◆ IsPortableMode()

bool WorkspaceManager::IsPortableMode ( ) const

Definition at line 51 of file WorkspaceManager.cpp.

                                            {
    // Check for STANDALONE.txt or PORTABLE.txt marker file.
    // The marker should live at the portable distribution root, which is
    // one level above bin\ on Windows (where the exe lives).
    // We also accept it in ./ (same dir as CWD) in case the user places it
    // next to the exe — GetPortableWorkspacePath() will still return ".."
    // so studies are never created inside bin\.
    if (FileExists("./STANDALONE.txt") || FileExists("../STANDALONE.txt") || FileExists("../../STANDALONE.txt")) {
        return true;
    }
 
    if (FileExists("./PORTABLE.txt") || FileExists("../PORTABLE.txt") || FileExists("../../PORTABLE.txt")) {
        return true;
    }
 
    // PEBL_PORTABLE environment variable (set by a batch file before launching)
    const char* portableEnv = getenv("PEBL_PORTABLE");
    if (portableEnv && strcmp(portableEnv, "1") == 0) {
        return true;
    }
 
    return false;
}

Referenced by CopyResources(), Initialize(), IsFirstRun(), and WorkspaceManager().

◆ SetWorkspacePath()

void WorkspaceManager::SetWorkspacePath ( const std::string & path )

inline

Definition at line 38 of file WorkspaceManager.h.

38{ mWorkspacePath = path; }

The documentation for this class was generated from the following files:

Public Member Functions

Detailed Description

Constructor & Destructor Documentation

◆ WorkspaceManager()

◆ ~WorkspaceManager()

Member Function Documentation

◆ CopyResources()

◆ CreateSnapshot()

◆ CreateStudyDirectory()

◆ GetChainsPath()

◆ GetDemoPath()

◆ GetDocsPath()

◆ GetScalesPath()

◆ GetSnapshotDirectories()

◆ GetSnapshotsPath()

◆ GetStudiesPath()

◆ GetStudyDirectories()

◆ GetTutorialPath()

◆ GetWorkspacePath()

◆ ImportSnapshot()

◆ Initialize()

◆ IsFirstRun()

◆ IsInitialized()

◆ IsPortableMode()

◆ SetWorkspacePath()