vos/metaobjects/property/fileproperty.cc

Go to the documentation of this file.

/*
    This file is part of the Virtual Object System of
    the Interreality project (http://interreality.org).

    Copyright (C) 2001, 2002 Peter Amstutz

    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 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

    Peter Amstutz <tetron@interreality.org>
    Additions by Reed Hedges <reed@zerohour.net> marked with initials "rh" and date.
*/
#include <stdio.h>
#include <errno.h>
#include <assert.h>

#include "fileproperty.hh"

#ifndef S_ISREG
#define S_ISREG(x) (x & _S_IFREG)
#endif


FileProperty::FileProperty(MetaObject* superobject)
    : MetaObject(superobject), Property(superobject), LocalProperty(superobject), filehandle(0)
{
}

FileProperty::FileProperty(MetaObject* superobject, const string& file_name, const string& datatype)
    : MetaObject(superobject), Property(superobject), LocalProperty(superobject, "", datatype), filehandle(0), filename(file_name)
{
    setFileBackend(file_name);
}

FileProperty::~FileProperty()
{
    if(filehandle) fclose(filehandle);
}

void FileProperty::registerExtenders()
{
    static bool done = false;
    if(! done) {
    LocalSite::addLocalObjectExtension(typeid(FileProperty).name(),
                                         &FileProperty::new_FileProperty);
    LocalSite::addLocalObjectExtension("property:property.file",
                                       &FileProperty::new_FileProperty);
    done = true;
    }
}


MetaObject* FileProperty::new_FileProperty(MetaObject* superobject, const string& type)
{
    return new FileProperty(superobject);
}

void FileProperty::checkOpenFile() throw (FileAccessError)
{
    if(! filehandle) {
        if(! (filehandle=fopen(filename.c_str(), "r+b"))) {
            if(errno == EACCES) {
                if(! (filehandle=fopen(filename.c_str(), "rb"))) {
                    throw FileAccessError(string(strerror(errno)) + " " + filename);
                }
                readonly = true;
            } else throw FileAccessError(string(strerror(errno)) + " " + filename);
        } else readonly = false;
        fstat(fileno(filehandle), &status);
    }
    struct stat curstat;

    fstat(fileno(filehandle), &curstat);

    // check if file has changed since opening it
    if(curstat.st_mtime > status.st_mtime) {
        fclose(filehandle);
        filehandle = 0;
        if(! (filehandle=fopen(filename.c_str(), "r+b"))) {
            throw FileAccessError(string(strerror(errno)) + " " + filename);
        }
        fstat(fileno(filehandle), &status); // now file status is up to date (and will not infitely recurse on call to getRawLength(), below)
        string s;
        readRaw(s, 0, getRawLength());

        vRef<PropertyEvent> event = new PropertyEvent(
            PropertyEvent::PropertyReplace,
            *this, *this,
            s, getDataType(), 
            false);

        for(PropertyListenerMap::iterator i = propertyListeners.begin();
            i != propertyListeners.end();
            i++) {
            (*i).second->notifyPropertyChange(*event);
        }

    }
}

void FileProperty::setFileBackend(const string& file_name, const string& data_type) throw(FileAccessError)
{
    if(filehandle) fclose(filehandle);
    filehandle=0;
    filename = file_name;
    raw_datatype = data_type;

    struct stat curstat;
    if(stat(file_name.c_str(), &curstat) != 0
        || ! S_ISREG(curstat.st_mode))
    {
        throw FileAccessError("No such file " + file_name);
    }
}

string FileProperty::getFileBackend()
{
    return filename;
}

int FileProperty::getRawLength() throw(FileAccessError)
{
    checkOpenFile();
    fseek(filehandle, 0, SEEK_END);
    return ftell(filehandle);
}

void FileProperty::readRaw(string& target, int start, int length) throw(FileAccessError)
{
    checkOpenFile();
    if(length < 0)
        length = getRawLength() - (0 - (length + 1));
    if(start < 0) start = getRawLength() + start + 1;
    if(start > getRawLength()) { target = ""; return; }
    char* b = (char*)malloc(length);
    fseek(filehandle, start, SEEK_SET);
    length = fread(b, 1, length, filehandle);
    target = string(b, length);
    free(b);
}

void FileProperty::read(string& target, int start, int length) throw(FileAccessError)
{
/* XXX NOT DONE */
    /* fileproperty is never "decoded" in memory (never stored in memory), always decode */
    readRaw(target, start, length);
    datatype = TypeChain::decode(target, getRawDataType());
    data_length = target.size();
}




void FileProperty::write(int start, const string& newdata) throw(FileAccessError)
{
    checkOpenFile();
    if(! readonly) {
        fseek(filehandle, start, SEEK_SET);
        fwrite(newdata.c_str(), newdata.size(), 1, filehandle);
        fstat(fileno(filehandle), &status);
        LocalProperty::write(0, "");
    } else {
        LOG("fileproperty", 2, "Tried to write to a read-only file " << filename);
    }
}

void FileProperty::replace(const string& newdata, const string& newtype) throw(FileAccessError)
{
    if(filehandle) fclose(filehandle);
    filehandle=0;

    if(! (filehandle=fopen(filename.c_str(), "w+b"))) {
        if(errno == EACCES) {
            if(! (filehandle=fopen(filename.c_str(), "rb"))) {
                throw FileAccessError(string(strerror(errno)) + " " + filename);
            }
            readonly = true;
            LOG("fileproperty", 2, "Tried to replace a read-only file " << filename);
        }
    } else readonly = false;
    if(! readonly) {
        fstat(fileno(filehandle), &status);
        write(0, newdata);

        Property::replace("", newtype);

        vRef<PropertyEvent> event = new PropertyEvent(
            PropertyEvent::PropertyReplace,
            *this, *this,
            newdata, newtype,
            false);

        for(PropertyListenerMap::iterator i = propertyListeners.begin(); i != propertyListeners.end(); i++) {
            (*i).second->notifyPropertyChange(*event);
        }
    }
}

---