First version of a class to represent the notion of an operating system

path to a file or directory and some rudimentary operations on them.


git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@15762 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Reid Spencer 2004-08-15 08:13:01 +00:00
parent da5f2abcb7
commit d5cda87995

214
include/llvm/System/Path.h Normal file
View File

@ -0,0 +1,214 @@
//===- Path.h - Implement the Path class ------------------------*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// Copyright (C) 2003 eXtensible Systems, Inc. All Rights Reserved.
//
// This program is open source software; you can redistribute it and/or modify
// it under the terms of the University of Illinois Open Source License. See
// LICENSE.TXT (distributed with this software) for details.
//
// This program 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.
//
//===----------------------------------------------------------------------===//
//
// This file declares the llvm::sys::Path class. The Path class provides the
// operating system agnostic concept of the name of a file or directory.
//
//===----------------------------------------------------------------------===//
/// @file lib/System/Path.h
/// @author Reid Spencer <raspencer@x10sys.com> (original author)
/// @version \verbatim $Id$ \endverbatim
/// @date 2004/08/14
/// @since 1.4
/// @brief Declares the llvm::sys::Path class.
//===----------------------------------------------------------------------===//
#ifndef LLVM_SYSTEM_PATH_H
#define LLVM_SYSTEM_PATH_H
#include "llvm/System/ErrorCode.h"
namespace llvm {
namespace sys {
/// This class provides an abstraction for the name of a path
/// to a file or directory in the filesystem.
/// @since 1.4
/// @brief An abstraction for operating system paths.
class Path : public std::string
{
/// @name Types
/// @{
public:
/// @brief An enumerator for specifying special ways to construct
/// the path.
enum ConstructSpecial {
CONSTRUCT_TEMP_FILE = 1, ///< make a temporary file name
CONSTRUCT_TEMP_DIR = 2, ///< Make a temporary directory name
};
/// @}
/// @name Constructors
/// @{
public:
/// Forward declare this because constructors need to use it.
/// @returns true if the path is valid
/// @brief Determines if the path is valid (properly formed) or not.
inline bool is_valid() const throw();
/// Creates a null (empty) path
/// @brief Default Constructor
Path () throw() {}
/// Creates a path from char*
/// @brief char* converter
Path ( const char * name ) throw() : std::string(name) {
assert(is_valid());
}
/// @brief std::string converter
Path ( const std::string& name ) throw() : std::string(name) {
assert(is_valid());
}
/// Copies the path with copy-on-write semantics. The \p this Path
/// will reference \p the that Path until one of them is modified
/// at which point a full copy is taken before the write.
/// @brief Copy Constructor
Path ( const Path & that ) throw() : std::string(that) {
assert(is_valid());
}
/// This constructor will construct the path using a special
/// construction argument that will pre-fill the path with the name
/// of some special path name
/// @brief Construct a special, well known path
Path( ConstructSpecial ) throw();
/// Releases storage associated with the Path object
/// @brief Destructor
~Path () throw() {}
/// @}
/// @name Operators
/// @{
public:
/// Makes a copy of \p that to \p this with copy-on-write semantics.
/// @returns \p this
/// @brief Assignment Operator
Path & operator = ( const Path & that ) throw() {
this->assign ( that );
return *this;
}
/// Comparies \p this Path with \p that Path for equality.
/// @returns true if \p this and \p that refer to the same item.
/// @brief Equality Operator
bool operator ==( const Path & that ) const throw() {
return 0 == this->compare( that ) ;
}
/// Comparies \p this Path with \p that Path for inequality.
/// @returns true if \p this and \p that refer to different items.
/// @brief Inequality Operator
bool operator !=( const Path & that ) const throw() {
return 0 != this->compare( that );
}
/// @}
/// @name Accessors
/// @{
public:
/// @returns true if the path could reference a file
/// @brief Determines if the path is valid for a file reference.
bool is_file() const throw();
/// @returns true if the path could reference a directory
/// @brief Determines if the path is valid for a directory reference.
bool is_directory() const throw();
/// @brief Fills and zero terminates a buffer with the path
inline void fill( char* buffer, uint32_t len ) const throw();
/// @}
/// @name Mutators
/// @{
public:
/// This ensures that the pathname is terminated with a /
/// @brief Make the path reference a directory.
ErrorCode make_directory() throw();
/// This ensures that the pathname is not terminated with a /
/// @brief Makes the path reference a file.
ErrorCode make_file() throw();
/// the file system.
/// @returns true if the pathname references an existing file.
/// @brief Determines if the path is a file or directory in
ErrorCode exists() throw();
/// The \p dirname is added to the end of the Path.
/// @param dirname A string providing the directory name to
/// be appended to the path.
/// @brief Appends the name of a directory.
ErrorCode append_directory( const std::string & dirname ) throw();
/// The \p filename is added to the end of the Path.
/// @brief Appends the name of a file.
ErrorCode append_file( const std::string& filename ) throw();
/// Directories will have no entries. Files will be zero length. If
/// the file or directory already exists, no error results.
/// @throws SystemException if any error occurs.
/// @brief Causes the file or directory to exist in the filesystem.
ErrorCode create( bool create_parents = false ) throw();
ErrorCode create_directory() throw();
ErrorCode create_directories() throw() ;
ErrorCode create_file() throw() ;
/// Directories must be empty before they can be removed. If not,
/// an error will result. Files will be unlinked, even if another
/// process is using them.
/// @brief Removes the file or directory from the filesystem.
ErrorCode remove() throw();
ErrorCode remove_directory() throw() ;
ErrorCode remove_file() throw() ;
/// Temporary file names are a common need. This method uses the
/// template in the existing path and uniquifies a file name based
/// on the template.
ErrorCode make_temp_file() throw();
/// Temporary directory names are a common need. This method uses
/// the template in the existing path and uniqufies a directory
/// name based on the template.
ErrorCode make_temp_directory() throw();
/// Find library.
ErrorCode find_lib( const char * file ) throw();
/// @}
};
inline bool Path::is_valid() const throw() {
if ( empty() ) return false;
return true;
}
inline void Path::fill( char* buffer, size_t bufflen ) const throw() {
size_t pathlen = length();
assert( bufflen > pathlen );
size_t copylen = pathlen <? (bufflen - 1);
this->copy(buffer, copylen, 0 );
buffer[ copylen ] = 0;
}
}
}
// vim: sw=2 smartindent smarttab tw=80 autoindent expandtab
#endif