blocxx

File.hpp

Go to the documentation of this file.
00001 /*******************************************************************************
00002 * Copyright (C) 2005, Quest Software, Inc. All rights reserved.
00003 * Copyright (C) 2006, Novell, Inc. All rights reserved.
00004 * 
00005 * Redistribution and use in source and binary forms, with or without
00006 * modification, are permitted provided that the following conditions are met:
00007 * 
00008 *     * Redistributions of source code must retain the above copyright notice,
00009 *       this list of conditions and the following disclaimer.
00010 *     * Redistributions in binary form must reproduce the above copyright
00011 *       notice, this list of conditions and the following disclaimer in the
00012 *       documentation and/or other materials provided with the distribution.
00013 *     * Neither the name of 
00014 *       Quest Software, Inc., 
00015 *       nor Novell, Inc., 
00016 *       nor the names of its contributors or employees may be used to 
00017 *       endorse or promote products derived from this software without 
00018 *       specific prior written permission.
00019 * 
00020 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
00021 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
00022 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
00023 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
00024 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
00025 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
00026 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
00027 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
00028 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
00029 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
00030 * POSSIBILITY OF SUCH DAMAGE.
00031 *******************************************************************************/
00032 
00033 
00039 #ifndef BLOCXX_FILE_HPP_INCLUDE_GUARD_
00040 #define BLOCXX_FILE_HPP_INCLUDE_GUARD_
00041 #include "blocxx/BLOCXX_config.h"
00042 #include "blocxx/Types.hpp"
00043 #include "blocxx/FileSystem.hpp"
00044 #include "blocxx/SafeBool.hpp"
00045 #include <algorithm> // for std::swap
00046 
00047 namespace BLOCXX_NAMESPACE
00048 {
00049 
00054 class BLOCXX_COMMON_API File
00055 {
00056 public:
00057    enum ELockType
00058    {
00064       E_READ_LOCK,
00070       E_WRITE_LOCK
00071    };
00072 
00076    File() : m_hdl(BLOCXX_INVALID_FILEHANDLE)
00077    {
00078    }
00083    File(const File& x);
00087    ~File();
00093    File& operator= (const File& x)
00094    {
00095       File(x).swap(*this);
00096       return *this;
00097    }
00098    void swap(File& x)
00099    {
00100       std::swap(m_hdl, x.m_hdl);
00101    }
00113    size_t read(void* bfr, size_t numberOfBytes, Int64 offset=-1L) const
00114    {
00115       return FileSystem::read(m_hdl, bfr, numberOfBytes, offset);
00116    }
00127    size_t write(const void* bfr, size_t numberOfBytes, Int64 offset=-1L)
00128    {
00129       return FileSystem::write(m_hdl, bfr, numberOfBytes, offset);
00130    }
00141    Int64 seek(Int64 offset, int whence) const
00142    {
00143       return FileSystem::seek(m_hdl, offset, whence);
00144    }
00149    Int64 tell() const
00150    {
00151       return FileSystem::tell(m_hdl);
00152    }
00156    void rewind() const
00157    {
00158       FileSystem::rewind(m_hdl);
00159    }
00163    UInt64 size() const
00164    {
00165       return FileSystem::fileSize(m_hdl);
00166    }
00171    int close()
00172    {
00173       if (m_hdl != BLOCXX_INVALID_FILEHANDLE)
00174       {
00175          int rv = FileSystem::close(m_hdl);
00176          m_hdl = BLOCXX_INVALID_FILEHANDLE;
00177          return rv;
00178       }
00179       return 0;
00180    }
00185    int flush()
00186    {
00187       return FileSystem::flush(m_hdl);
00188    }
00204    int getLock(ELockType type = E_WRITE_LOCK);
00220    int tryLock(ELockType type = E_WRITE_LOCK);
00227    int unlock();
00228 
00232    BLOCXX_SAFE_BOOL_IMPL(File, FileHandle, File::m_hdl, (m_hdl != BLOCXX_INVALID_FILEHANDLE))
00233 
00234    
00239    bool operator==(const File& rhs)
00240    {
00241       return m_hdl == rhs.m_hdl;
00242    }
00243 
00244    File(FileHandle hdl) : m_hdl(hdl)
00245    {
00246    }
00247 
00248 private:
00249 
00250    FileHandle  m_hdl;
00251 };
00252 
00253 } // end namespace BLOCXX_NAMESPACE
00254 
00255 #endif
00256