---

FileName.cc

Go to the documentation of this file.

/*
    File:       FileName.cc

    Function:   Implements FileName.h

    Author:     Andrew Willmott

    Notes:      
*/

#include "cl/FileName.h"
#include "cl/CLConfig.h"
#include <stdio.h>
#include <sys/stat.h>
#include <stdlib.h>
#include <unistd.h>

Void FileName::RemoveExtension()
{
    Int     dotPos;
    
    dotPos = name.FindCharLast('.');

    if (dotPos >= 0)
    {
        extension = name.Suffix(-1 - dotPos);
        name = name.Prefix(dotPos);
    }
    else
        extension = "";
}

Void FileName::AddExtension(StrConst ext)
{
    name = name + "." + extension;
    extension = ext;
}

String FileName::GetPath() const
{
    String result;
    
#ifdef CL_MACOS
    result.Printf("%s.%s", name.CString(), extension.CString());
#else
    if (extension == "")
        result.Printf("%s/%s", path.CString(), name.CString());
    else
        result.Printf("%s/%s.%s", path.CString(), name.CString(), extension.CString());
#endif

    return(result);
}

FileName &FileName::SetPath(StrConst filePath)
{
    Int         slashPos;
    TempString  thePath = SubstituteEnvVars(filePath);

    slashPos = thePath.FindCharLast('/');
    
    if (slashPos >= 0)
    {
        path = thePath.Prefix(slashPos);
        name = thePath.Suffix(-1 - slashPos);
    }
    else
    {
        path = ".";
        name = thePath;
    }

    RemoveExtension();

    return(SELF);
}

FileName &FileName::SetRelPath(StrConst filePath)
{
    Int         slashPos;
    TempString  thePath = SubstituteEnvVars(filePath);
    
    if (thePath[0] == '/')
    // absolute path
        return(SetPath(filePath));

    slashPos = thePath.FindCharLast('/');
    
    if (slashPos >= 0)
    {
        path = path + "/" + thePath.Prefix(slashPos);
        name = thePath.Suffix(-(slashPos + 1));
    }
    else
        name = thePath;

    RemoveExtension();

    return(SELF);
}

Bool FileName::Exists() const
{
    return(access(GetPath().CString(), F_OK) == 0);
}

Bool FileName::IsReadable() const
{
    return(access(GetPath().CString(), R_OK) == 0);
}

Bool FileName::IsWritable() const
{
    return(access(GetPath().CString(), W_OK) == 0);
}

Long FileName::GetTimeStamp() const
{
    struct stat statInfo;
    
    stat(GetPath().CString(), &statInfo);

    return(statInfo.st_mtime);
}

String TempPath()
{
    String result = SubstituteEnvVars("$TMPDIR");

    if (result[0] == '<')
        result = "/tmp";

    return(result);
}

StrConst tCompressExtensions[] =
{
    "gz",
    "bz2",
    "Z",
    0
};


Int FileName::FindFileExtension(StrConst extensions[], Bool allowCompressed)
{
    Int         i, j;
    Bool        extWasSet;
    
    flags.Clear();
    
    extWasSet = (extension != "");

    if (extWasSet)
    // an extension is already set -- at most we might have to 
    // tack on a compression suffix.
    {
        // remove any compression suffix
        if (allowCompressed)
            for (j = 0; !tCompressExtensions[j].IsNull(); j++)
                if (extension == tCompressExtensions[j])
                {
                    if (IsReadable())
                        flags.Set(1 << j);
                    RemoveExtension();
                    break;
                }

        // check that the extension is valid
        for (i = 0; !extensions[i].IsNull(); i++)
            if (extension == extensions[i])
                break;

        if (extensions[i].IsNull())
            return(kBadExtension);

        if (flags.IsSet(FN_IsCompressed) || IsReadable())
            return(i);
        else
        {
            if (allowCompressed)
            // try it with a compression extension
            {
                AddExtension("");

                for (j = 0; !tCompressExtensions[j].IsNull(); j++)
                {
                    SetExtension(tCompressExtensions[j]);

                    if (IsReadable())
                    {
                        RemoveExtension();
                        flags.Set(1 << j);

                        return(i);
                    }
                }
                
                RemoveExtension();
            }

            return(kFileNotFound);
        }
    }

    // try all possible extensions and compressions
    for (i = 0; !extensions[i].IsNull(); i++)
    {
        SetExtension(extensions[i]);

        if (IsReadable()) 
            return(i);

        // try it with a compression extension
        if (allowCompressed)
        {
            AddExtension("");

            for (j = 0; !tCompressExtensions[j].IsNull(); j++)
            {
                SetExtension(tCompressExtensions[j]);

                if (IsReadable())
                {
                    RemoveExtension();
                    flags.Set(1 << j);

                    return(i);
                }
            }
            
            RemoveExtension();
        }
    }

    SetExtension("");

    return(kFileNotFound);
}

FileName &FileName::MakeUnique()
{
    if (Exists())
    {
        String  origName = name;
        Int     i = 0;

        do
        {
            i++;
            name.Printf("%s-%d", origName.CString(), i);
        }
        while (Exists());
    }

    return(SELF);
}

Void FileName::AddCompExt()
{
    if (flags.IsSet(FN_Gzipped))
        AddExtension("gz");
    else if (flags.IsSet(FN_Bz2ed))
        AddExtension("bz2");
    else if (flags.IsSet(FN_Compress))
        AddExtension("Z");
}

Int FileName::DecompressSetup()
{
    if (flags.IsSet(FN_IsCompressed))
    {
        String      origFile;
        StrConst    cmd;
        Int         err;

        AddCompExt();
        origFile = GetPath();
        RemoveExtension();
        SetDir(TempPath());

        if (flags.IsSet(FN_Gzipped))
            cmd = "gunzip -c";
        else if (flags.IsSet(FN_Bz2ed))
            cmd = "bunzip2 -c";
        else if (flags.IsSet(FN_Compress))
            cmd = "compress -c";

        if (system(cmd + " " + origFile + " > " + GetPath()) != 0)
            return(-1);
    }

    return(0);
}

Void FileName::DecompressCleanup()
{
    if (flags.IsSet(FN_IsCompressed))
        unlink(GetPath());
}

---