/scr/tee1/isis/lib/Core/DataStorage/fileptr.hpp

Go to the documentation of this file.

//
//  fileptr.hpp
//  isis
//
//  Created by Enrico Reimer on 08.08.11.
//  Copyright 2011 __MyCompanyName__. All rights reserved.
//

#ifndef FILEPTR_HPP
#define FILEPTR_HPP

#define BOOST_FILESYSTEM_VERSION 2 //@todo remove as soon as we switch to boost 1.42
#include <boost/filesystem.hpp>
#include <boost/detail/endian.hpp>
#include "valuearray.hpp"
#include "endianess.hpp"

#ifdef WIN32
#include <windows.h>
#define FILE_HANDLE HANDLE
#else
#define FILE_HANDLE int
#endif

namespace isis
{
namespace data
{
class FilePtr: public ValueArray<uint8_t>
{
    struct Closer {
        FILE_HANDLE file, mmaph;
        size_t len;
        boost::filesystem::path filename;
        bool write;
        void operator()( void *p );
    };
    typedef data::ValueArrayReference( *generator_type )( data::FilePtr &, size_t, size_t, bool );
    struct GeneratorMap: public std::map<unsigned short, generator_type> {
        GeneratorMap();
        template<class T> static data::ValueArrayReference generator( data::FilePtr &mfile, size_t offset, size_t len, bool swap_endianess ) {
            return mfile.at<T>( offset, len, swap_endianess );
        }
        struct proc {
            std::map<unsigned short, generator_type> *m_map;
            proc( std::map<unsigned short, generator_type> *map ): m_map( map ) {}
            template<class T> void operator()( const T & ) {
                m_map->insert( std::make_pair( ValueArray<T>::staticID, &generator<T> ) );
            }
        };
    };

    bool map( FILE_HANDLE file, size_t len, bool write, const boost::filesystem::path &filename );

    size_t checkSize( bool write, FILE_HANDLE file, const boost::filesystem::path &filename, size_t size = 0 );
    bool m_good, writing;
public:
    FilePtr();
    FilePtr( const boost::filesystem::path &filename, size_t len = 0, bool write = false );

    template<typename T> ValueArray<T> at( size_t offset, size_t len = 0, bool swap_endianess = false ) {
        boost::shared_ptr<T> ptr = boost::static_pointer_cast<T>( getRawAddress( offset ) );

        if( len == 0 ) {
            len = ( getLength() - offset ) / sizeof( T );
            LOG_IF( ( getLength() - offset ) % sizeof( T ), Runtime, warning )
                    << "The remaining filesize " << getLength() - offset << " does not fit the bytesize of the requested type "
                    << util::Value<T>::staticName();
        }

        LOG_IF( len * sizeof( T ) > ( getLength() - offset ), Debug, error )
                << "The requested length will be " << len - ( getLength() - offset ) << " bytes behind the end of the file.";
        LOG_IF( writing && swap_endianess, Debug, warning )
                << "Ignoring requested to swap byte order for writing (the systems byte order is " << BOOST_BYTE_ORDER << " and that will be used)";

        if( writing || !swap_endianess ) { // if not endianess swapping was requested or T is not float (or if we are writing)
            return data::ValueArray<T>( ptr, len ); // return a cheap copy
        } else { // flip bytes into a new ValueArray
            LOG( Debug, info ) << "Byte swapping " <<  ValueArray<T>::staticName() << " for endianess";
            ValueArray<T> ret( len );
            data::endianSwapArray( ptr.get(), ptr.get() + std::min( len, getLength() / sizeof( T ) ), ret.begin() );
            return ret;
        }

    }

    data::ValueArrayReference atByID( unsigned short ID, size_t offset, size_t len = 0, bool swap_endianess = false );

    bool good();
    void release();
};

}
}

#endif