FS_Traverse.h

Go to the documentation of this file.

/*
 * PROPRIETARY INFORMATION.  This software is proprietary to
 * Side Effects Software Inc., and is not to be reproduced,
 * transmitted, or disclosed in any way without written permission.
 *
 * NAME:        FS_Traverse.h (FS Library, C++)
 *
 * COMMENTS:
 */

#ifndef __FS_Traverse__
#define __FS_Traverse__

#include "FS_Info.h"
#include <UT/UT_Array.h>
#include <UT/UT_StringArray.h>
#include <UT/UT_WorkBuffer.h>

namespace FS
{
    /// Utility function to process the contents of the traverse() function
    template <bool DIR, typename T>
    bool
    process(T &func,
            UT_WorkBuffer &fullpath,
            exint fullpath_len,
            const UT_StringArray &paths,
            const UT_Array<FS_Stat> &stats)
    {
        for (exint i = 0, n = paths.size(); i < n; ++i)
        {
            fullpath.truncate(fullpath_len);
            fullpath.append(paths[i]);
            if (DIR)
            {
                if (!func.dir(fullpath.buffer(), stats[i]))
                    return false;
            }
            else
            {
                if (!func.file(fullpath.buffer(), stats[i]))
                    return false;
            }
        }
        return true;
    }

    /// FS function to process all files in a directory.  The template functor
    /// should have two methods:
    ///    - bool dir(const char *path, const FS_Stat &stat);
    ///    - bool file(const char *path, const FS_Stat &stat);
    /// If either of these functions returns false, traversal will be terminated
    ///
    /// For example, to list all files in a directory: @code
    ///     struct FileList {
    ///         bool file(const char *dir, const FS_Stat &stat) const {
    ///             if (myRecursive) {
    ///                 printf("%s/\n", dir);
    ///                 FS::traverse(dir, this);
    ///             }
    ///         }
    ///         bool file(const char *path, const FS_Stat &stat) const {
    ///             printf("%s\n", path);
    ///         }
    ///         bool    myRecursive = true;
    ///     };
    /// @endcode
    template <typename T>
    void
    traverse(T &func,
            const char *path,
            bool sort_contents=false,
            bool directories_first=true)
    {
        FS_Info                 info(path);
        if (!info.getIsDirectory())
        {
            FS_Stat stat;
            if (FS_Info::statFile("", path, &stat))
                func.file(path, stat);
            return;
        }

        UT_WorkBuffer   fullpath;
        if (!UTisstring(path))
            fullpath.strcpy("./");
        else
        {
            fullpath.strcpy(path);
            if (fullpath.last() != '/')
                fullpath.append('/');
        }
        exint   olen = fullpath.length();

        UT_StringArray          files;
        UT_StringArray          dirs;
        UT_Array<FS_Stat>       stats;
        UT_Array<FS_Stat>       dir_stats;
        if (info.getContents(files, &dirs, &stats, &dir_stats))
        {
            // Traverse directories first
            if (sort_contents)
            {
                dirs.sort();
                files.sort();
            }
            if (directories_first)
            {
                if (!process<true, T>(func, fullpath, olen, dirs, dir_stats))
                    return;
            }
            if (!process<false, T>(func, fullpath, olen, files, stats))
                return;
            if (!directories_first)
            {
                if (!process<true, T>(func, fullpath, olen, dirs, dir_stats))
                    return;
            }
        }
    }
}

#endif