Composite_FileAccess.c

Go to the documentation of this file.

 
 
#include <stdlib.h>
#include <string.h>
#include <time.h>
 
#include "helpers/datetime.h"
#include "helpers/replace.h"
#include "helpers/split.h"
#include "helpers/strdup.h"
 
#include "Composite_FileDirEntry.h"
#include "Composite_FileAccess.h"
 
static FileDirEntry* _root = NULL;
 
 
FileDirEntry* _NewFileEntry(const char* name, long length, time_t whenModified)
{
    FileEntry* fileEntry = calloc(1, sizeof(FileEntry));
    if (fileEntry != NULL)
    {
        fileEntry->base.name = name;
        fileEntry->base.length = length;
        fileEntry->base.whenModified = whenModified;
        fileEntry->base.fileDirType = FileDirType_File;
    }
 
    return (FileDirEntry*)fileEntry;
}
 
DirEntry* _NewDirEntry(const char* name, time_t whenModified)
{
    DirEntry* dirEntry = calloc(1, sizeof(DirEntry));
    if (dirEntry != NULL)
    {
        dirEntry->base.name = name;
        dirEntry->base.whenModified = whenModified;
        dirEntry->base.fileDirType = FileDirType_Directory;
    }
 
    return dirEntry;
}
 
void _AddChild(DirEntry* dirEntry, FileDirEntry* child)
{
    if (dirEntry != NULL && child != NULL)
    {
        if (dirEntry->_children == NULL)
        {
            dirEntry->_children = child;
        }
        else
        {
            FileDirEntry* nextChild = dirEntry->_children;
            while (nextChild->next != NULL)
            {
                nextChild = nextChild->next;
            }
            nextChild->next = child;
        }
    }
}
 
static void _DestroyTree(FileDirEntry* root)
{
    if (root != NULL)
    {
        if (root->fileDirType == FileDirType_Directory)
        {
            DirEntry* dirEntry = (DirEntry*)root;
            _DestroyTree(dirEntry->_children);
        }
        free(root);
    }
}
 
static void _ConstructTree(void)
{
    if (_root == NULL)
    {
        time_t now = datetime_now();
        DirEntry* dirEntry = _NewDirEntry("root", now);
        if (dirEntry == NULL)
        {
            return;
        }
        _root = (FileDirEntry*)dirEntry;
 
        FileDirEntry* fileEntry = _NewFileEntry("FileA.txt", 101, now);
        if (fileEntry == NULL)
        {
            _DestroyTree(_root);
            return;
        }
        _AddChild(dirEntry, fileEntry);
 
        fileEntry = _NewFileEntry("FileB.txt", 102, now);
        if (fileEntry == NULL)
        {
            _DestroyTree(_root);
            return;
        }
        _AddChild(dirEntry, fileEntry);
 
        fileEntry = _NewFileEntry("FileC.txt", 103, now);
        if (fileEntry == NULL)
        {
            _DestroyTree(_root);
            return;
        }
        _AddChild(dirEntry, fileEntry);
 
        DirEntry* subDirEntry = _NewDirEntry("subdir1", now);
        if (subDirEntry == NULL)
        {
            _DestroyTree(_root);
            return;
        }
        _AddChild(dirEntry, (FileDirEntry*)subDirEntry);
 
        fileEntry = _NewFileEntry("FileD.txt", 104, now);
        if (fileEntry == NULL)
        {
            _DestroyTree(_root);
            return;
        }
        _AddChild(subDirEntry, fileEntry);
 
        fileEntry = _NewFileEntry("FileE.txt", 105, now);
        if (fileEntry == NULL)
        {
            _DestroyTree(_root);
            return;
        }
        _AddChild(subDirEntry, fileEntry);
 
        DirEntry* subsubDirEntry = _NewDirEntry("subdir2", now);
        if (subsubDirEntry == NULL)
        {
            _DestroyTree(_root);
            return;
        }
        _AddChild(subDirEntry, (FileDirEntry*)subsubDirEntry);
 
 
        fileEntry = _NewFileEntry("FileF.txt", 106, now);
        if (fileEntry == NULL)
        {
            _DestroyTree(_root);
            return;
        }
        _AddChild(subsubDirEntry, fileEntry);
 
        fileEntry = _NewFileEntry("FileG.txt", 107, now);
        if (fileEntry == NULL)
        {
            _DestroyTree(_root);
            return;
        }
        _AddChild(subsubDirEntry, fileEntry);
    }
}
 
 
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
 
static FileDirEntry* _FindEntry(char* path)
{
    _ConstructTree();
 
    FileDirEntry* root = _root;
    if (root != NULL)
    {
        SplitList pathComponents = { 0 };
        split(path, "/", &pathComponents);
        if (pathComponents.strings_count > 0)
        {
            size_t numComponents = pathComponents.strings_count;
            for (size_t index = 0; index < numComponents; index++)
            {
                const char* rootName = FileDirEntry_GetName(root);
                if (strcmp(rootName, pathComponents.strings[index]) != 0)
                {
                    // Mismatch in path to this entry, bad path
                    root = NULL;
                    break;
                }
 
                if ((index + 1) >= numComponents)
                {
                    // Reached end of path so we found what was asked for.
                    break;
                }
 
                // Still haven't reached end of specified path, look at
                // the current root for children.
 
                FileDirEntry* child = FileDirEntry_GetChildren(root);
                if (child == NULL)
                {
                    // Path included leaf in the middle, bad path
                    break;
                }
 
                root = NULL; // Assume we won't find anything
                // Look ahead in the path for a matching child.
                const char* childComponent = pathComponents.strings[index + 1];
                while (child != NULL)
                {
                    const char* childName = FileDirEntry_GetName(child);
                    if (strcmp(childName, childComponent) == 0)
                    {
                        root = child;
                        break;
                    }
                    child = child->next;
                }
 
                if (root == NULL)
                {
                    // Couldn't find matching child, bad path
                    break;
                }
            }
        }
        SplitList_Clear(&pathComponents);
    }
 
    return root;
}
 
// Composite_FileAccess_GetEntry()
FileDirEntry* Composite_FileAccess_GetEntry(const char* path)
{
    FileDirEntry* foundEntry = NULL;
 
    if (path != NULL)
    {
        // _FindEntry() modifies the path string so create duplicate to work with.
        char* filepath = STRDUP(path);
        if (filepath != NULL)
        {
            replace_chr(filepath, '\\', '/');
            foundEntry = _FindEntry(filepath);
 
            free(filepath);
        }
    }
 
    return foundEntry;
}