How to detect if a folder is too heavy, and if so delete part of it

Question

i need to control if a folder defined by a path is full of folders, if those folders are too much i need to delete, for example half of them, from the older one the newest one. Practically i need to make space for future folders.

void fCID(long pThreadId)
{
 ULARGE_INTEGER rFreeBytesAvailable, rTotalNumberOfBytes, rTotalNumberOfFreeBytes;
 if(sc.LB.TMCI && sc.LB.ISM == 1)
 {
   for(10000000000;10000000000 > sd;sd--) //wrong, i'm looking for it
   {
    if (::GetDiskFreeSpaceEx (NULL, &rFreeBytesAvailable, &rTotalNumberOfBytes, 
      &rTotalNumberOfFreeBytes))
      {
       if (rFreeBytesAvailable.QuadPart > 10000000000)     //10gb
        {
         fAFOZA("C:\\S\\H1\\CA");   //function zip   
        }
       else
       {
        sd=sd - 50% of (LA); //sd = space disposable
       }
      }
    }
  }
else  
{
fDFOP(where.Trace_C_P);  //not interesting
fDFOP(where.Trace_C_CL_P); //not interesting
}
}

This code is only an idea

ULARGE_INTEGER rFreeBytesAvailable, rTotalNumberOfBytes, 
rTotalNumberOfFreeBytes;
if(sc.LB.TMCI && sc.LB.ISM == 1)
{
if (::GetDiskFreeSpaceEx ("C:\\S\\H1\\CA\\LA", &rFreeBytesAvailable, &rTotalNumberOfBytes, &rTotalNumberOfFreeBytes))
{
  do
    {
      fDFOP("C:\\S\\H1\\CA\\LA"); //this function deletes what's inside the path
    }while(rFreeBytesAvailable.QuadPart == 10000000000)
    if (rFreeBytesAvailable.QuadPart > 10000000000)     //10gb
    {
      fAFOZA("C:\\S\\H1\\CA");//this one makes a zip 
    }
 }
}

this is another possible implementation maybe

Answer 1

If you want to remove the oldest files in a directory structure to reclaim a certain amount of space, you could use the C++17 std::filesystem library class recursive_directory_iterator and the functions last_write_time and remove from the same library.

Example:

#include <cstdint>
#include <filesystem>
#include <set>
#include <string>
#include <system_error>
#include <tuple>

namespace fs = std::filesystem;

// a class containing the interesting information about each file
struct file {
    fs::path path;
    std::uintmax_t file_size;
    std::filesystem::file_time_type write_time;

    // An operator< to be able to sort files in this order:
    //  ascending write_time
    //  decending file_size (to remove the biggest of two files with the same write_time)
    //  ascending path
    bool operator<(const file& rhs) const {
        return
            std::tie(write_time, rhs.file_size, path) <
            std::tie(rhs.write_time, file_size, rhs.path);
    }
};

// A function to traverse a directory structure, collect file names, age and sizes
// and to remove the oldest until "bytes_to_remove" bytes have been removed
std::uintmax_t rm_old_files(const std::wstring& dir, std::uintmax_t bytes_to_remove) {
    std::uintmax_t bytes_removed = 0;
    std::set<file> files; // the set will sort file entries with the oldest first

    // collect all regular files in the directory structure starting at "dir"
    for (const fs::directory_entry& de : fs::recursive_directory_iterator(dir)) {
        if (de.is_regular_file()) {
            files.emplace(file{de, de.file_size(), fs::last_write_time(de)});
        }
    }

    // remove files until at least "bytes_to_remove" bytes have been removed
    std::error_code ec; // unread but used to prevent exceptions in fs::remove
    for (auto const& [path, file_size, write_time] : files) {
        std::wcout << L"removing " << path << L'\n';

        /* uncomment this part when you've made sure that it'll
           remove the correct files.
        if (fs::remove(path, ec)) {
            bytes_removed += file_size;
            if (bytes_removed >= bytes_to_remove) break;
        }
        */
    }

    return bytes_removed;
}

Example usage:

std::wstring dir = L"C:\\S\\H1\\CA\\LA";
ULARGE_INTEGER FreeBytesAvailableToCaller;
ULARGE_INTEGER TotalNumberOfBytes;
ULARGE_INTEGER TotalNumberOfFreeBytes;

if (GetDiskFreeSpaceExW(dir.c_str(), &FreeBytesAvailableToCaller,
                                     &TotalNumberOfBytes, 
                                     &TotalNumberOfFreeBytes)) {
    // if less than half the total number of bytes are available,
    // execute rm_old_files to try to make at least half available.
    if (FreeBytesAvailableToCaller.QuadPart < TotalNumberOfBytes.QuadPart/2) {
        auto bytes_removed = 
            rm_old_files(dir, TotalNumberOfBytes.QuadPart/2 -
                              FreeBytesAvailableToCaller.QuadPart);
        std::wcout << L"removed " << bytes_removed << L" bytes\n";
    }
}