AlphabeticSDFileList.cpp

/*
AlphabeticSDFileList.cpp - Library for listing SD files in a directory on alphabetic order.
Created by Terence F. Golla, April 17, 2022
Released into the public domain.
*/

#include "AlphabeticSDFileList.h"

/// <summary>
/// Class constructor.
/// </summary>
AlphabeticSDFileList::AlphabeticSDFileList() { }

/// <summary>
/// Class initializer.
/// </summary>
/// <param name="SdFat">The SD Fat object created to read the card.</param>
/// <param name="directory">The directory on the SD to list.</param>
/// <param name="contiguous">Boolean indicating Previous and Next are 
/// to loop through the directory start to end and end to start.</param>
/// <remarks>If you add files to the directory you will need to re-execute Begin.</remarks>
void AlphabeticSDFileList::Begin(SdFat &SdFat, char *directory, bool contiguous)
{
  AlphabeticSDFileList::SD = &SdFat;
  AlphabeticSDFileList::contiguous = contiguous;
  AlphabeticSDFileList::directory = directory;

  strcpy(first, "");
  strcpy(last,  "");
  strcpy(current, "");

  char filename[DEFAULT_FILE_NAME_SIZE];

  File directoryFile = SD->open(directory);

  // Loop through entire directory (file list). Note the file list is not ordered.
  while (true) {
    File file =  directoryFile.openNextFile();

    if (!file) {
      // no more files
      break;
    }

    file.getName(filename, DEFAULT_FILE_NAME_SIZE);

    // If we are looking at a filename (not a directory)
    if (!file.isDirectory()) {
      // If the first filename is empty, fill first and last.
      if (stricmp(first, "") == 0) {
        strcpy(first, filename);
        strcpy(last, filename);
      }
      else {
        // If the filename is less than the first filename, place it in first.
        if (stricmp(filename, first) < 0) {
          strcpy(first, filename);
        }
        else {
          // If the filename is greater than the last filename, place it in last.
          if (stricmp(filename, last) > 0) {
            strcpy(last, filename);
          }
        }
      }
    } 

    file.close();
  }
}

/// <summary>
/// String compare without case sensitivity.
/// </summary>
/// <param name="s1">The first string (string1).</param>
/// <param name="s2">The second string (string2).</param>
/// <returns>Less than 0 if string1 is less than string2. 0 if string1 equivalent to string2. Greater than 0 if string1 is greater than string2.</returns>
int AlphabeticSDFileList::stricmp(const char *s1, const char *s2)
{
  while (tolower((unsigned char) *s1) == tolower((unsigned char) *s2)) {
    if (*s1 == '\0')
      return 0;
    s1++; s2++;
  }

  return (int) tolower((unsigned char) *s1) - (int) tolower((unsigned char) *s2);
}

/// <summary>
/// The first file in the directory.
/// </summary>
char* AlphabeticSDFileList::First()
{
  return first;
}

/// <summary>
/// The last file in the directory.
/// </summary>
char* AlphabeticSDFileList::Last()
{
  return last;
}

/// <summary>
/// The current file as you progress through the list.
/// </summary>
char* AlphabeticSDFileList::Current()
{
  return current;
}

/// <summary>
/// Moves to the previous file in the list.
/// </summary>
/// <returns>The previous filename.</returns>
/// <remarks>
/// If contiguous was set to true and the current file is the fisrt file in the list 
/// Previous will return the last file in the list.
/// If contiguous was set to false and the current file is the fisrt file in the list 
/// Previous will return a blank filename.
/// </remarks>
char* AlphabeticSDFileList::Previous()
{
  char filename[DEFAULT_FILE_NAME_SIZE];
  char previous[DEFAULT_FILE_NAME_SIZE];

  strcpy(previous, "");

  if (stricmp(current, "") == 0)
    strcpy(current, "\x7F");

  File directoryFile = SD->open(directory);

  // Loop through entire directory (file list). Note the file list is not ordered.
  while (true) {
    File file =  directoryFile.openNextFile();

    if (!file) {
      // no more files
      break;
    }

    file.getName(filename, DEFAULT_FILE_NAME_SIZE);

    // If we are looking at a filename (not a directory).
    if (!file.isDirectory()) {
      // If the filename is less than the current filename, it might be the previous file.
      if (stricmp(filename, current) < 0) {
        // If the previous filename is empty, fill it with the filename.
        if (stricmp(previous, "") == 0) {
          strcpy(previous, filename);
        }
        else {
          // If the filename is greater than the previous filename, make it the previous filename.
          if (stricmp(filename, previous) > 0) {
            strcpy(previous, filename);
          }
        }
      }
    } 

    file.close();
  }

  if (contiguous && stricmp(previous, "") == 0)
    strcpy(previous, last);

  strcpy(current, previous);
  return current;
}

/// <summary>
/// Moves to the next file in the list.
/// </summary>
/// <returns>The next filename.</returns>
/// <remarks>
/// If contiguous was set to true and the current file is the last file in the list 
/// Next will return the first file in the list.
/// If contiguous was set to false and the current file is the last file in the list 
/// Previous will return a blank filename.
/// </remarks>
char* AlphabeticSDFileList::Next()
{
  char filename[DEFAULT_FILE_NAME_SIZE];
  char next[DEFAULT_FILE_NAME_SIZE];

  strcpy(next, "");

  File directoryFile = SD->open(directory);

  // Loop through entire directory (file list). Note the file list is not ordered.
  while (true) {
    File file =  directoryFile.openNextFile();

    if (!file) {
      // no more files
      break;
    }

    file.getName(filename, DEFAULT_FILE_NAME_SIZE);

    // If we are looking at a filename (not a directory).
    if (!file.isDirectory()) {
      // If the filename is greater than the current filename, it might be the next file.
      if (stricmp(filename, current) > 0) {
        // If the next filename is empty, fill it with the filename.
        if (stricmp(next, "") == 0) {
          strcpy(next, filename);
        }
        else {
          // If the filename is less than the next filename, make it the next filename.
          if (stricmp(filename, next) < 0) {
            strcpy(next, filename);
          }
        }
      }
    } 

    file.close();
  }

  if (contiguous && stricmp(next, "") == 0)
    strcpy(next, first);

  strcpy(current, next);
  return current;
}

/// <summary>
/// Finds the closest match to the provided filename.
/// </summary>
/// <param name="filename">The filename to match.</param>
/// <returns>The closest match to the provided filename.</returns>
char* AlphabeticSDFileList::Find(char *findFilename)
{
  char filename[DEFAULT_FILE_NAME_SIZE];
  char next[DEFAULT_FILE_NAME_SIZE];

  strcpy(current, last);

  File directoryFile = SD->open(directory);

  // Loop through entire directory (file list). Note the file list is not ordered.
  while (true) {
    File file =  directoryFile.openNextFile();

    if (!file) {
      // no more files
      break;
    }

    file.getName(filename, DEFAULT_FILE_NAME_SIZE);

    // If we are looking at a filename (not a directory).
    if (!file.isDirectory()) {
      // If the current filename is empty, fill it.  
      if (stricmp(current, "") == 0) {
        strcpy(current, filename);
      }
      else {
        // If the filename is greater than or equal the find filename.
        if (stricmp(filename, findFilename) >= 0) {
          // If the filename is less than the current filename, fill the current filename.
          if (stricmp(filename, current) < 0) {
            strcpy(current, filename);
          }
        }
      }
    } 

    file.close();
  }

  return current;
}