Autonomy Software C++ 24.5.1
Welcome to the Autonomy Software repository of the Mars Rover Design Team (MRDT) at Missouri University of Science and Technology (Missouri S&T)! API reference contains the source code and other resources for the development of the autonomy software for our Mars rover. The Autonomy Software project aims to compete in the University Rover Challenge (URC) by demonstrating advanced autonomous capabilities and robust navigation algorithms.
Loading...
Searching...
No Matches
Public Member Functions | Static Public Member Functions | Static Public Attributes | Private Attributes | List of all members
duckdb::FileOpenFlags Class Reference

Public Member Functions

constexpr FileOpenFlags (idx_t flags)
 
constexpr FileOpenFlags (FileLockType lock)
 
constexpr FileOpenFlags (FileCompressionType compression)
 
constexpr FileOpenFlags (idx_t flags, FileLockType lock, FileCompressionType compression)
 
constexpr FileOpenFlags operator| (FileOpenFlags b) const
 
FileOpenFlags & operator|= (FileOpenFlags b)
 
FileLockType Lock ()
 
FileCompressionType Compression ()
 
void SetCompression (FileCompressionType new_compression)
 
CachingMode GetCachingMode ()
 
void SetCachingMode (CachingMode new_caching_mode)
 
void Verify ()
 
bool OpenForReading () const
 
bool OpenForWriting () const
 
bool DirectIO () const
 
bool CreateFileIfNotExists () const
 
bool OverwriteExistingFile () const
 
bool OpenForAppending () const
 
bool CreatePrivateFile () const
 
bool ReturnNullIfNotExists () const
 
bool RequireParallelAccess () const
 
bool ExclusiveCreate () const
 
bool ReturnNullIfExists () const
 
bool MultiClientAccess () const
 
bool DisableLogging () const
 
bool EnableExtensionInstall () const
 
idx_t GetFlagsInternal () const
 

Static Public Member Functions

static constexpr FileLockType MergeLock (FileLockType a, FileLockType b)
 
static constexpr FileCompressionType MergeCompression (FileCompressionType a, FileCompressionType b)
 
static constexpr CachingMode MergeCachingMode (CachingMode a, CachingMode b)
 

Static Public Attributes

static constexpr idx_t FILE_FLAGS_READ = idx_t(1 << 0)
 
static constexpr idx_t FILE_FLAGS_WRITE = idx_t(1 << 1)
 
static constexpr idx_t FILE_FLAGS_DIRECT_IO = idx_t(1 << 2)
 
static constexpr idx_t FILE_FLAGS_FILE_CREATE = idx_t(1 << 3)
 
static constexpr idx_t FILE_FLAGS_FILE_CREATE_NEW = idx_t(1 << 4)
 
static constexpr idx_t FILE_FLAGS_APPEND = idx_t(1 << 5)
 
static constexpr idx_t FILE_FLAGS_PRIVATE = idx_t(1 << 6)
 
static constexpr idx_t FILE_FLAGS_NULL_IF_NOT_EXISTS = idx_t(1 << 7)
 
static constexpr idx_t FILE_FLAGS_PARALLEL_ACCESS = idx_t(1 << 8)
 
static constexpr idx_t FILE_FLAGS_EXCLUSIVE_CREATE = idx_t(1 << 9)
 
static constexpr idx_t FILE_FLAGS_NULL_IF_EXISTS = idx_t(1 << 10)
 
static constexpr idx_t FILE_FLAGS_MULTI_CLIENT_ACCESS = idx_t(1 << 11)
 
static constexpr idx_t FILE_FLAGS_DISABLE_LOGGING = idx_t(1 << 12)
 
static constexpr idx_t FILE_FLAGS_ENABLE_EXTENSION_INSTALL = idx_t(1 << 13)
 

Private Attributes

idx_t flags = 0
 
FileLockType lock = FileLockType::NO_LOCK
 
CachingMode caching_mode = CachingMode::NO_CACHING
 
FileCompressionType compression = FileCompressionType::UNCOMPRESSED
 

Constructor & Destructor Documentation

◆ FileOpenFlags() [1/4]

constexpr duckdb::FileOpenFlags::FileOpenFlags ( idx_t  flags)
inlineconstexpr
7739 : flags(flags) { // NOLINT: allow implicit conversion
7740 }

◆ FileOpenFlags() [2/4]

constexpr duckdb::FileOpenFlags::FileOpenFlags ( FileLockType  lock)
inlineconstexpr
7741 : lock(lock) { // NOLINT: allow implicit conversion
7742 }

◆ FileOpenFlags() [3/4]

constexpr duckdb::FileOpenFlags::FileOpenFlags ( FileCompressionType  compression)
inlineconstexpr
7744 : compression(compression) {
7745 }

◆ FileOpenFlags() [4/4]

constexpr duckdb::FileOpenFlags::FileOpenFlags ( idx_t  flags,
FileLockType  lock,
FileCompressionType  compression 
)
inlineconstexpr
7747 : flags(flags), lock(lock), compression(compression) {
7748 }

Member Function Documentation

◆ MergeLock()

static constexpr FileLockType duckdb::FileOpenFlags::MergeLock ( FileLockType  a,
FileLockType  b 
)
inlinestaticconstexpr
7750 {
7751 return a == FileLockType::NO_LOCK ? b : a;
7752 }

◆ MergeCompression()

static constexpr FileCompressionType duckdb::FileOpenFlags::MergeCompression ( FileCompressionType  a,
FileCompressionType  b 
)
inlinestaticconstexpr
7754 {
7755 return a == FileCompressionType::UNCOMPRESSED ? b : a;
7756 }

◆ MergeCachingMode()

static constexpr CachingMode duckdb::FileOpenFlags::MergeCachingMode ( CachingMode  a,
CachingMode  b 
)
inlinestaticconstexpr
7758 {
7759 return a == CachingMode::NO_CACHING ? b : a;
7760 }

◆ operator|()

constexpr FileOpenFlags duckdb::FileOpenFlags::operator| ( FileOpenFlags  b) const
inlineconstexpr
7762 {
7763 return FileOpenFlags(flags | b.flags, MergeLock(lock, b.lock), MergeCompression(compression, b.compression));
7764 }

◆ operator|=()

FileOpenFlags & duckdb::FileOpenFlags::operator|= ( FileOpenFlags  b)
inline
7765 {
7766 flags |= b.flags;
7767 lock = MergeLock(lock, b.lock);
7768 compression = MergeCompression(compression, b.compression);
7769 caching_mode = MergeCachingMode(caching_mode, b.caching_mode);
7770 return *this;
7771 }

◆ Lock()

FileLockType duckdb::FileOpenFlags::Lock ( )
inline
7773 {
7774 return lock;
7775 }

◆ Compression()

FileCompressionType duckdb::FileOpenFlags::Compression ( )
inline
7777 {
7778 return compression;
7779 }

◆ SetCompression()

void duckdb::FileOpenFlags::SetCompression ( FileCompressionType  new_compression)
inline
7781 {
7782 compression = new_compression;
7783 }

◆ GetCachingMode()

CachingMode duckdb::FileOpenFlags::GetCachingMode ( )
inline
7785 {
7786 return caching_mode;
7787 }

◆ SetCachingMode()

void duckdb::FileOpenFlags::SetCachingMode ( CachingMode  new_caching_mode)
inline
7788 {
7789 caching_mode = new_caching_mode;
7790 }

◆ Verify()

void duckdb::FileOpenFlags::Verify ( )
73583 {
73584#ifdef DEBUG
73585 bool is_read = flags & FileOpenFlags::FILE_FLAGS_READ;
73586 bool is_write = flags & FileOpenFlags::FILE_FLAGS_WRITE;
73587 bool is_create =
73588 (flags & FileOpenFlags::FILE_FLAGS_FILE_CREATE) || (flags & FileOpenFlags::FILE_FLAGS_FILE_CREATE_NEW);
73589 bool is_private = (flags & FileOpenFlags::FILE_FLAGS_PRIVATE);
73590 bool null_if_not_exists = flags & FileOpenFlags::FILE_FLAGS_NULL_IF_NOT_EXISTS;
73591 bool exclusive_create = flags & FileOpenFlags::FILE_FLAGS_EXCLUSIVE_CREATE;
73592 bool null_if_exists = flags & FileOpenFlags::FILE_FLAGS_NULL_IF_EXISTS;
73593
73594 // require either READ or WRITE (or both)
73595 D_ASSERT(is_read || is_write);
73596 // CREATE/Append flags require writing
73597 D_ASSERT(is_write || !(flags & FileOpenFlags::FILE_FLAGS_APPEND));
73598 D_ASSERT(is_write || !(flags & FileOpenFlags::FILE_FLAGS_FILE_CREATE));
73599 D_ASSERT(is_write || !(flags & FileOpenFlags::FILE_FLAGS_FILE_CREATE_NEW));
73600 // cannot combine CREATE and CREATE_NEW flags
73601 D_ASSERT(!(flags & FileOpenFlags::FILE_FLAGS_FILE_CREATE && flags & FileOpenFlags::FILE_FLAGS_FILE_CREATE_NEW));
73602
73603 // For is_private can only be set along with a create flag
73604 D_ASSERT(!is_private || is_create);
73605 // FILE_FLAGS_NULL_IF_NOT_EXISTS cannot be combined with CREATE/CREATE_NEW
73606 D_ASSERT(!(null_if_not_exists && is_create));
73607 // FILE_FLAGS_EXCLUSIVE_CREATE only can be combined with CREATE/CREATE_NEW
73608 D_ASSERT(!exclusive_create || is_create);
73609 // FILE_FLAGS_NULL_IF_EXISTS only can be set with EXCLUSIVE_CREATE
73610 D_ASSERT(!null_if_exists || exclusive_create);
73611#endif
73612}

◆ OpenForReading()

bool duckdb::FileOpenFlags::OpenForReading ( ) const
inline
7794 {
7795 return flags & FILE_FLAGS_READ;
7796 }

◆ OpenForWriting()

bool duckdb::FileOpenFlags::OpenForWriting ( ) const
inline
7797 {
7798 return flags & FILE_FLAGS_WRITE;
7799 }

◆ DirectIO()

bool duckdb::FileOpenFlags::DirectIO ( ) const
inline
7800 {
7801 return flags & FILE_FLAGS_DIRECT_IO;
7802 }

◆ CreateFileIfNotExists()

bool duckdb::FileOpenFlags::CreateFileIfNotExists ( ) const
inline
7803 {
7804 return flags & FILE_FLAGS_FILE_CREATE;
7805 }

◆ OverwriteExistingFile()

bool duckdb::FileOpenFlags::OverwriteExistingFile ( ) const
inline
7806 {
7807 return flags & FILE_FLAGS_FILE_CREATE_NEW;
7808 }

◆ OpenForAppending()

bool duckdb::FileOpenFlags::OpenForAppending ( ) const
inline
7809 {
7810 return flags & FILE_FLAGS_APPEND;
7811 }

◆ CreatePrivateFile()

bool duckdb::FileOpenFlags::CreatePrivateFile ( ) const
inline
7812 {
7813 return flags & FILE_FLAGS_PRIVATE;
7814 }

◆ ReturnNullIfNotExists()

bool duckdb::FileOpenFlags::ReturnNullIfNotExists ( ) const
inline
7815 {
7816 return flags & FILE_FLAGS_NULL_IF_NOT_EXISTS;
7817 }

◆ RequireParallelAccess()

bool duckdb::FileOpenFlags::RequireParallelAccess ( ) const
inline
7818 {
7819 return flags & FILE_FLAGS_PARALLEL_ACCESS;
7820 }

◆ ExclusiveCreate()

bool duckdb::FileOpenFlags::ExclusiveCreate ( ) const
inline
7821 {
7822 return flags & FILE_FLAGS_EXCLUSIVE_CREATE;
7823 }

◆ ReturnNullIfExists()

bool duckdb::FileOpenFlags::ReturnNullIfExists ( ) const
inline
7824 {
7825 return flags & FILE_FLAGS_NULL_IF_EXISTS;
7826 }

◆ MultiClientAccess()

bool duckdb::FileOpenFlags::MultiClientAccess ( ) const
inline
7827 {
7828 return flags & FILE_FLAGS_MULTI_CLIENT_ACCESS;
7829 }

◆ DisableLogging()

bool duckdb::FileOpenFlags::DisableLogging ( ) const
inline
7830 {
7831 return flags & FILE_FLAGS_DISABLE_LOGGING;
7832 }

◆ EnableExtensionInstall()

bool duckdb::FileOpenFlags::EnableExtensionInstall ( ) const
inline
7833 {
7834 return flags & FILE_FLAGS_ENABLE_EXTENSION_INSTALL;
7835 }

◆ GetFlagsInternal()

idx_t duckdb::FileOpenFlags::GetFlagsInternal ( ) const
inline
7836 {
7837 return flags;
7838 }
The documentation for this class was generated from the following files: