Filename.cc

Go to the documentation of this file.

/*
 * Filename.cc
 *
 * Smalltalk like class library for C++
 * File name handler and tools.
 *
 * Copyright (c) 2004 Milan Cermak
 */
/*
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */
#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include <dirent.h>
#include <fcntl.h>
#include <stlib/tools/Filename.h>

#include <stlib/ByteArray.h>
#include <stlib/Character.h>
#include <stlib/ExternalReadStream.h>
#include <stlib/ExternalReadAppendStream.h>
#include <stlib/ExternalWriteStream.h>
#include <stlib/FileAccessor.h>
#include <stlib/OrderedCollection.h>
#include <stlib/ReadStream.h>
#include <stlib/Stream.h>
#include <stlib/String.h>
#include <stlib/WriteStream.h>
#include <stlib/tools/FileEncodedStreamFactory.h>

#include <stlib/Error.h>

using namespace Tools;

Filename::Filename(String *name)
{
    public_name = name;
    local_name = public_name->asCString();
}

Filename::Filename(const char *name)
{
    public_name = new String(name);
    local_name = public_name->asCString();
}

Filename::~Filename(void)
{
    GC_free(local_name);
}

/* Class-accessing protocol */
String *Filename::className(void) const
{
    return new String("Filename");
}

/* Instance creation protocol */
Filename *Filename::construct(String *extra)
{
    return new Filename(constructString(extra));
}

Filename *Filename::construct(const char *extra)
{
    return construct(new String(extra));
}

Filename *Filename::construct(Filename *extra)
{
    return construct(extra->asString());
}

String *Filename::constructString(String *extra)
{
    Character *sep = separator();
    String *prefix = asString();
    String *suffix;
    Stream *ws;
    if (!extra->isEmpty() && extra->first()->isEqual(sep)) {
        suffix = dynamic_cast<String *>(extra->copy(1, extra->size()));
    } else {
        suffix = extra;
    }
    ws = (new String(prefix->size() + suffix->size() + 1))->writeStream();
    ws->nextPutAll(prefix);
    if (prefix->isEmpty() || !prefix->first()->isEqual(sep)) {
        ws->nextPut(sep);
    }
    ws->nextPutAll(suffix);
    return dynamic_cast<String *>(ws->contents());
}

/* Class-constants protocol */
Character *Filename::separator(void)
{
    return Character::value('/');
}

/* Class-defaults protocol */
Filename *Filename::currentDirectory(void)
{
    return new Filename(currentDirectoryString());
}

String *Filename::currentDirectoryString(void)
{
    char *buffer = getcwd(NULL, 0);
    String *fn = new String(buffer);
    free((void *) buffer);
    return fn;
}

/* Class-utilities protocol */
OrderedCollection *Filename::filesMatching(String *pattern)
{
    OrderedCollection *allFiles = new OrderedCollection;
    OrderedCollection *list = components(pattern);

    if (list->isEmpty()) return allFiles;
    baseDirectoryForList(list)->filesMatchingAccessList(list, allFiles);
    return allFiles;
}

/* Class-testing protocol */
bool Filename::isCaseSensitive(void)
{
    return true;
}

/* Accessing protocol */
const char *Filename::localName(void) const
{
    return local_name;
}

/* Comparing protocol */
long Filename::hash(void) const
{
    return asString()->asUppercase()->hash();
}

bool Filename::isEqual(const Object *obj) const
{
    if (!obj->className()->isEqual(className())) return false;
    const Filename *fn = dynamic_cast<const Filename *>(obj);
    if (isCaseSensitive()) {
        return asString()->isEqual(fn->asString());
    } else {
        // return asString()->sameAs(fn->asString());
        return asString()->asUppercase()->isEqual(fn->asString()->asUppercase());
    }
}

/* Converting protocol */
Filename *Filename::asFilename(void)
{
    return this;
}

String *Filename::asString(void) const
{
    return public_name;
}

/* File utilities protocol */
void Filename::beCurrentDirectory(void)
{
    if (!(exists() && isDirectory())) {
        error(new String("Receiver must be an existing directory."),
              new String(__PRETTY_FUNCTION__));
    }
    setCurrentDirectory(this);
}

void Filename::copyTo(Filename *destName)
{
    if (link(localName(), destName->localName()) == 0) return;
    privateCopy(FileAccessor::openFileReadOnly(asString()),
                FileAccessor::openFileWriteOnly(destName->asString()));
}

void Filename::copyTo(String *destName)
{
    copyTo(new Filename(destName));
}

OrderedCollection *Filename::directoryContents(void)
{
    OrderedCollection *allFiles = new OrderedCollection;
    DIR *dir;
    struct dirent *entry;

    dir = opendir(localName());
    if (dir == NULL) return allFiles;
    while ((entry = readdir(dir)) != NULL) {
        allFiles->add(new String(entry->d_name));
    }
    closedir(dir);
    return allFiles;
}

void Filename::erase(void)
{
    int retCode = remove(localName());
    if (retCode < 0) {
        error(new String("Unexpected error"),
              new String(__PRETTY_FUNCTION__));
    }
}

long Filename::fileSize(void)
{
    struct stat buf;

    stat(localName(), &buf);
    return buf.st_size;
}

void Filename::makeDirectory(void)
{
    int retCode = mkdir(localName(), 0777);
    if (retCode < 0) {
        error(new String("Unexpected error"),
              new String(__PRETTY_FUNCTION__));
    }
}

void Filename::moveTo(Filename *destName)
{
    copyTo(destName);
    erase();
}

void Filename::moveTo(String *destName)
{
    moveTo(new Filename(destName));
}

void Filename::renameTo(Filename *destName)
{
    if (rename(localName(), destName->localName()) == 0) return;
    moveTo(destName);
}

void Filename::renameTo(String *destName)
{
    renameTo(new Filename(destName));
}

/* Parsing protocol */
Filename *Filename::baseDirectoryForList(OrderedCollection *list)
{
    if (dynamic_cast<String *>(list->first())->first()->isEqual(separator())) {
        return new Filename(dynamic_cast<String *>(list->removeFirst()));
    } else {
        return currentDirectory();
    }
}

String *Filename::readBaseLocationFromStream(PositionableStream *stream)
{
    if (stream->peekFor(separator())) {
        if (stream->peekFor(separator())) {
            return String::with(separator(), separator());
        }
        return String::with(separator());
    }
    return new String;
}

OrderedCollection *Filename::components(void)
{
    return components(asString());
}

OrderedCollection *Filename::components(String *name)
{
    OrderedCollection *components = new OrderedCollection;
    ReadStream *stream = name->readStream();

    String *component = readBaseLocationFromStream(stream);
    if (!component->isEmpty()) components->add(component);
    while (!stream->atEnd())
        components->add(stream->upTo(separator()));
    return components;
}

Filename *Filename::directory(void)
{
    return new Filename(head());
}

String *Filename::extension(void)
{
    String *t = tail();
    int periodIndex = t->lastIndexOf('.');
    if (periodIndex <= 0) return nil;
    return dynamic_cast<String *>(t->copy(periodIndex, t->size()));
}

String *Filename::head(void)
{
    long index = lastSeparatorIndex();
    if (index >= 0) {
        index = (index > 1) ? index : 1;
        return dynamic_cast<String *>(asString()->copy(0, index));
    } else {
        return currentDirectoryString();
    }
}

String *Filename::tail(void)
{
    String *nm = asString();
    long index = lastSeparatorIndex();
    if (index >= 0) {
        return dynamic_cast<String *>(nm->copy(index + 1, nm->size()));
    } else {
        return dynamic_cast<String *>(nm->copy());
    }
}

/* Printing protocol */
void Filename::printOn(Stream *stream)
{
    Object::printOn(stream);
    stream->nextPut('(');
    stream->print(public_name);
    stream->nextPut(')');
}

/* Stream creation protocol */
FileEncodedStreamFactory *Filename::withEncoding(String *encoding)
{
    return new FileEncodedStreamFactory(this, encoding);
}

FileEncodedStreamFactory *Filename::withEncoding(const char *encoding)
{
    return withEncoding(new String(encoding));
}

ExternalWriteStream *Filename::appendStream(void)
{
    FileAccessor *accessor;
    accessor = new FileAccessor(public_name, O_WRONLY, O_APPEND | O_CREAT);
    return accessor->writeStream();
}

ExternalReadStream *Filename::readStream(void)
{
    return FileAccessor::openFileReadOnly(public_name)->readStream();
}

ExternalReadAppendStream *Filename::readAppendStream(void)
{
    FileAccessor *accessor;
    accessor = new FileAccessor(public_name, O_RDWR, O_APPEND | O_CREAT);
    return accessor->readAppendStream();
}

ExternalWriteStream *Filename::writeStream(void)
{
    return FileAccessor::openFileWriteOnly(public_name)->writeStream();
}

/* Testing protocol */
bool Filename::exists(void)
{
    struct stat buf;

    return stat(localName(), &buf) == 0;
}

bool Filename::isAbsolute(void)
{
    if (public_name->isEmpty()) return false;
    return public_name->first()->isEqual(separator());
}

bool Filename::isDirectory(void)
{
    struct stat buf;

    stat(localName(), &buf);
    return S_ISDIR(buf.st_mode);
}

bool Filename::isReadable(void)
{
    struct stat buf;
    int mask;

    stat(localName(), &buf);
    mask = S_IROTH & ((getegid() == buf.st_gid) ? S_IRGRP : 0)
                   & ((geteuid() == buf.st_uid) ? S_IRUSR : 0);
    return (buf.st_mode & mask) != 0;
}

bool Filename::isRelative(void)
{
    return !isAbsolute();
}

bool Filename::isWritable(void)
{
    struct stat buf;
    int mask;

    stat(localName(), &buf);
    mask = S_IWOTH & ((getegid() == buf.st_gid) ? S_IWGRP : 0)
                   & ((geteuid() == buf.st_uid) ? S_IWUSR : 0);
    return (buf.st_mode & mask) != 0;
}

ByteArray *Filename::contentOfEntireFile(void)
{
    Stream *stream;
    ByteArray *content;

    _ensure(
        stream = readStream();
        content = dynamic_cast<ByteArray *>(stream->contents())
    ,
        stream->close()
    );

    return content;
}

/* Private protocol */
OrderedCollection *Filename::filesMatchingAccessList(OrderedCollection *list,
                                                     OrderedCollection *result)
{
    if (list->isEmpty()) return result;
    if (dynamic_cast<String *>(list->first())->isEqual(".")) {
        list->removeFirst();
        return filesMatchingAccessList(list, result);
    }
    if (dynamic_cast<String *>(list->first())->isEqual("..")) {
        list->removeFirst();
        return (construct("..")->filesMatchingAccessList(list, result));
    }
    return privFilesMatchingAccessList(list, result);
}

long Filename::lastSeparatorIndex(void)
{
    return asString()->lastIndexOf(separator());
}

void Filename::privateCopy(FileAccessor *source, FileAccessor *destination)
{
    int bufSize = source->bufferSize();
    ByteArray *buffer = new ByteArray(bufSize);
    int amountRead;

    _ensure (
        while ((amountRead = source->readInto(buffer)) > 0) {
            destination->writeFrom(buffer, 0, amountRead);
        }
        ,
        source->close();
        destination->close();
    );
}

OrderedCollection *Filename::privFilesMatchingAccessList(OrderedCollection *list,
                                                         OrderedCollection *result)
{
    Filename *fullname;
    String *pref = dynamic_cast<String *>(list->first());
    OrderedCollection *sublist;

    sublist = dynamic_cast<OrderedCollection *>(list->copy(1, list->size()));
    if (!(pref->includes('*') || pref->includes('#'))) {
        fullname = construct(pref);
        if (sublist->isEmpty()) {
            if (fullname->exists()) result->add(fullname->asString());
        } else {
            if (fullname->exists() && fullname->isDirectory())
                filesMatchingAccessList(sublist, result);
        }
        return result;
    }

    OrderedCollection *contents = directoryContents();
    int length = contents->size();
    for (int i = 0; i < length; i++) {
        String *name = dynamic_cast<String *>(contents->at(i));
        if (pref->match(name, !isCaseSensitive())) {
            fullname = construct(name);
            if (sublist->isEmpty()) {
                result->add(fullname->asString());
            } else {
                if (fullname->isDirectory())
                    filesMatchingAccessList(sublist, result);
            }
        }
    }
    return result;
}

void Filename::setCurrentDirectory(Filename *directory)
{
    int retCode = chdir(directory->localName());
    if (retCode < 0) {
        (new Error(new String("Unexpected error"),
                   new String(__PRETTY_FUNCTION__),
                   directory))->raise();
    }
}

---