low_level_io.h
/*
* Software License Agreement (BSD License)
*
* Point Cloud Library (PCL) - www.pointclouds.org
* Copyright (c) 2012-, Open Perception, Inc.
* Copyright (c) 2018 Fizyr BV. - https://fizyr.com
*
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above
* copyright notice, this list of conditions and the following
* disclaimer in the documentation and/or other materials provided
* with the distribution.
* * Neither the name of the copyright holder(s) nor the names of its
* contributors may be used to endorse or promote products derived
* from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
* ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*/
/**
* This file defines compatibility wrappers for low level I/O functions.
* Implemented as inlinable functions to prevent any performance overhead.
*/
#pragma once
#ifdef _WIN32
# ifndef WIN32_LEAN_AND_MEAN
# define WIN32_LEAN_AND_MEAN
# endif
# ifndef NOMINMAX
# define NOMINMAX
# endif
# include <io.h>
# include <windows.h>
# ifdef _MSC_VER
// ssize_t is already defined in MinGW and its definition conflicts with that of
// SSIZE_T on a 32-bit target, so do this only for MSVC.
# include <basetsd.h>
using ssize_t = SSIZE_T;
# endif /* _MSC_VER */
#else
# include <unistd.h>
# include <sys/mman.h>
# include <sys/types.h>
# include <sys/stat.h>
# include <sys/fcntl.h>
# include <cerrno>
#endif
#include <cstddef>
namespace pcl
{
namespace io
{
#ifdef _WIN32
inline int raw_open(const char * pathname, int flags, int mode)
{
return ::_open(pathname, flags, mode);
}
inline int raw_open(const char * pathname, int flags)
{
return ::_open(pathname, flags);
}
inline int raw_close(int fd)
{
return ::_close(fd);
}
inline int raw_lseek(int fd, long offset, int whence)
{
return ::_lseek(fd, offset, whence);
}
inline int raw_read(int fd, void * buffer, std::size_t count)
{
return ::_read(fd, buffer, count);
}
inline int raw_write(int fd, const void * buffer, std::size_t count)
{
return ::_write(fd, buffer, count);
}
inline int raw_ftruncate(int fd, long length)
{
return ::_chsize(fd, length);
}
inline int raw_fallocate(int fd, long length)
{
// Doesn't actually allocate, but best we can do?
return raw_ftruncate(fd, length);
}
#else
inline int raw_open(const char * pathname, int flags, int mode)
{
return ::open(pathname, flags, mode);
}
inline int raw_open(const char * pathname, int flags)
{
return ::open(pathname, flags);
}
inline int raw_close(int fd)
{
return ::close(fd);
}
inline off_t raw_lseek(int fd, off_t offset, int whence)
{
return ::lseek(fd, offset, whence);
}
inline ssize_t raw_read(int fd, void * buffer, std::size_t count)
{
return ::read(fd, buffer, count);
}
inline ssize_t raw_write(int fd, const void * buffer, std::size_t count)
{
return ::write(fd, buffer, count);
}
inline int raw_ftruncate(int fd, off_t length)
{
return ::ftruncate(fd, length);
}
# ifdef __APPLE__
inline int raw_fallocate(int fd, off_t length)
{
// OS X doesn't have posix_fallocate, but it has a fcntl that does the job.
// It may make the file too big though, so we truncate before returning.
// Try to allocate contiguous space first.
::fstore_t store = {F_ALLOCATEALL | F_ALLOCATECONTIG, F_PEOFPOSMODE, 0, length, 0};
if (::fcntl(fd, F_PREALLOCATE, &store) != -1)
return raw_ftruncate(fd, length);
// Try fragmented if it failed.
store.fst_flags = F_ALLOCATEALL;
if (::fcntl(fd, F_PREALLOCATE, &store) != -1)
return raw_ftruncate(fd, length);
// Fragmented also failed.
return -1;
}
# else // __APPLE__
inline int raw_fallocate(int fd, off_t length)
{
# ifdef ANDROID
// Android's libc doesn't have posix_fallocate.
if (::fallocate(fd, 0, 0, length) == 0)
return 0;
# else
// Conforming POSIX systems have posix_fallocate.
if (::posix_fallocate(fd, 0, length) == 0)
return 0;
# endif
// EINVAL should indicate an unsupported filesystem.
// All other errors are passed up.
if (errno != EINVAL)
return -1;
// Try to deal with unsupported filesystems by simply seeking + writing.
// This may not really allocate space, but the file size will be set.
// Writes to the mmapped file may still trigger SIGBUS errors later.
// Remember the old position and seek to the desired length.
off_t old_pos = raw_lseek(fd, 0, SEEK_CUR);
if (old_pos == -1)
return -1;
if (raw_lseek(fd, length - 1, SEEK_SET) == -1)
return -1;
// Write a single byte to resize the file.
char buffer = 0;
ssize_t written = raw_write(fd, &buffer, 1);
// Seek back to the old position.
if (raw_lseek(fd, old_pos, SEEK_SET) == -1)
return -1;
// Fail if we didn't write exactly one byte,
if (written != 1)
return -1;
return 0;
}
# endif // __APPLE
#endif // _WIN32
}
}
pcl::io::raw_ftruncate
int raw_ftruncate(int fd, long length)
Definition: low_level_io.h:105
pcl::io::raw_close
int raw_close(int fd)
Definition: low_level_io.h:85
pcl::io::raw_lseek
int raw_lseek(int fd, long offset, int whence)
Definition: low_level_io.h:90
pcl::io::raw_write
int raw_write(int fd, const void *buffer, std::size_t count)
Definition: low_level_io.h:100
pcl::io::raw_fallocate
int raw_fallocate(int fd, long length)
Definition: low_level_io.h:110
pcl::io::raw_open
int raw_open(const char *pathname, int flags, int mode)
Definition: low_level_io.h:75
pcl::io::raw_read
int raw_read(int fd, void *buffer, std::size_t count)
Definition: low_level_io.h:95
pcl
Definition: convolution.h:46