#include <FileSystemStorage.h>

Inheritance diagram for OpenDDS::FileSystemStorage::Directory:

Collaboration diagram for OpenDDS::FileSystemStorage::Directory:

[legend]

Classes
class	Iterator

Public Types
typedef RcHandle< Directory >	Ptr

typedef Iterator< File >	FileIterator

typedef Iterator< Directory >	DirectoryIterator

Public Member Functions
FileIterator	begin_files ()

FileIterator	end_files ()

RcHandle< File >	get_file (const char *name)

RcHandle< File >	create_next_file ()
	assumes all files in this dir are created with this API More...

DirectoryIterator	begin_dirs ()

DirectoryIterator	end_dirs ()

Directory::Ptr	get_dir (const OPENDDS_VECTOR(OPENDDS_STRING)&path)

Directory::Ptr	get_subdir (const char *name)

Directory::Ptr	create_next_dir ()
	assumes all subdirectories in this dir are created with this API More...

void	remove ()

OPENDDS_STRING	name () const

Directory::Ptr	parent () const

Public Member Functions inherited from OpenDDS::DCPS::RcObject
virtual	~RcObject ()

virtual void	_add_ref ()

virtual void	_remove_ref ()

long	ref_count () const

WeakObject *	_get_weak_object () const

Static Public Member Functions
static Ptr	create (const char *root_path)

Private Member Functions
ACE_TString	full_path (const ACE_TString &relative) const

typedef	OPENDDS_MAP (ACE_TString, ACE_TString) Map

	Directory (const ACE_TString &root_path, const ACE_TString &logical, const Directory::Ptr &parent)

void	scan_dir (const ACE_TString &relative, DDS_Dirent &dir, unsigned int overflow_index)

RcHandle< File >	make_new_file (const ACE_TString &t_name)

void	removing (const ACE_TString &logical_child, bool file)

Directory::Ptr	make_new_subdir (const ACE_TString &logical)

ACE_TString	add_entry ()

	OPENDDS_MAP (unsigned int, unsigned int) overflow_

	OPENDDS_MAP (ACE_TString, unsigned int) long_names_

Private Attributes
Directory::Ptr	parent_

ACE_TString	physical_dirname_

ACE_TString	logical_dirname_

Map	files_

Map	dirs_

Friends
class	File

template<typename T , typename U0 , typename U1 , typename U2 >
RcHandle< T >	OpenDDS::DCPS::make_rch (const U0 &, const U1 &, const U2 &)

Additional Inherited Members
Protected Member Functions inherited from OpenDDS::DCPS::RcObject
	RcObject ()

Detailed Description

Definition at line 98 of file FileSystemStorage.h.

Member Typedef Documentation

◆ DirectoryIterator

typedef Iterator<Directory> OpenDDS::FileSystemStorage::Directory::DirectoryIterator

Definition at line 173 of file FileSystemStorage.h.

◆ FileIterator

typedef Iterator<File> OpenDDS::FileSystemStorage::Directory::FileIterator

Definition at line 172 of file FileSystemStorage.h.

◆ Ptr

typedef RcHandle<Directory> OpenDDS::FileSystemStorage::Directory::Ptr

Definition at line 100 of file FileSystemStorage.h.

Constructor & Destructor Documentation

◆ Directory()

OpenDDS::FileSystemStorage::Directory::Directory	(	const ACE_TString &	root_path,
		const ACE_TString &	logical,
		const Directory::Ptr &	parent
	)

private

Definition at line 759 of file FileSystemStorage.cpp.

References ACE_TEXT(), ACE_String_Base< char >::c_str(), DDS_Dirent, physical_dirname_, and scan_dir().

   : parent_(parent)
   , physical_dirname_(dirname)
   , logical_dirname_(logical)
 {
   add_slash(physical_dirname_);
 
   bool ok(true);
   DDS_Dirent dir;
 
   if (dir.open(physical_dirname_.c_str()) == -1) {
     ok = false;
 
     if (errno == ENOENT && dds_mkdir(physical_dirname_.c_str()) != -1
         && dir.open(physical_dirname_.c_str()) != -1) {
       ok = true;
     }
   }
 
   if (!ok) throw std::runtime_error("Can't open or create directory");
 
   scan_dir(ACE_TEXT(""), dir, 0);
 }

Member Function Documentation

◆ add_entry()

ACE_TString OpenDDS::FileSystemStorage::Directory::add_entry ( )

private

Definition at line 693 of file FileSystemStorage.cpp.

References ACE_TEXT(), ACE_String_Base< char >::c_str(), OPENDDS_FILESYSTEMSTORAGE_MAX_FILES_PER_DIR, and OPENDDS_MAP.

 {
   if (overflow_.empty()) {
     overflow_[0] = 1;
     return ACE_TEXT("");
   }
 
   typedef OPENDDS_MAP(unsigned int, unsigned int)::iterator iterator;
   // find existing overflow bucket with capacity
   bool found_gap(false);
   unsigned int last_seen(0), unused_bucket(0);
 
   for (iterator iter = overflow_.begin(), end = overflow_.end();
        iter != end; ++iter) {
     if (iter->second < OPENDDS_FILESYSTEMSTORAGE_MAX_FILES_PER_DIR) {
       ++iter->second;
 
       if (iter->first == 0) return ACE_TEXT("");
 
       return overflow_dir_name(iter->first);
     }
 
     if (!found_gap && iter->first > last_seen + 1) {
       found_gap = true;
       unused_bucket = last_seen + 1;
     }
 
     last_seen = iter->first;
   }
 
   if (!found_gap) {
     if (last_seen == FSS_MAX_OVERFLOW_DIR) {
       throw std::runtime_error("Overflow serial # out of range.");
     }
 
     unused_bucket = last_seen + 1;
   }
 
   overflow_[unused_bucket] = 1;
   ACE_TString dir_name = overflow_dir_name(unused_bucket);
   CwdGuard cg(physical_dirname_);
 
   if (dds_mkdir(dir_name.c_str()) == -1) {
     throw std::runtime_error("Can't create overflow directory");
   }
 
   return dir_name;
 }

◆ begin_dirs()

Directory::DirectoryIterator OpenDDS::FileSystemStorage::Directory::begin_dirs ( )

Definition at line 593 of file FileSystemStorage.cpp.

References OpenDDS::DCPS::rchandle_from().

 {
   return DirectoryIterator(dirs_.begin(),  rchandle_from(this));
 }

◆ begin_files()

Directory::FileIterator OpenDDS::FileSystemStorage::Directory::begin_files ( )

Definition at line 527 of file FileSystemStorage.cpp.

References OpenDDS::DCPS::rchandle_from().

 {
   return FileIterator(files_.begin(), rchandle_from(this));
 }

◆ create()

Directory::Ptr OpenDDS::FileSystemStorage::Directory::create ( const char * root_path )

static

If root_path is relative it is up to the application to make sure the current directory is not changed while this object or any of its "child" objects are still alive.

Definition at line 517 of file FileSystemStorage.cpp.

References ACE_TEXT(), and ACE_TEXT_CHAR_TO_TCHAR.

 {
   return DCPS::make_rch<Directory>(ACE_TEXT_CHAR_TO_TCHAR(dirname), ACE_TEXT(""), Directory::Ptr ());
 }

◆ create_next_dir()

Directory::Ptr OpenDDS::FileSystemStorage::Directory::create_next_dir ( )

assumes all subdirectories in this dir are created with this API

Definition at line 628 of file FileSystemStorage.cpp.

References ACE_String_Base< char >::end().

 {
   ACE_TString logical;
 
   if (dirs_.empty()) {
     logical = FSS_DEFAULT_DIR_NAME;
 
   } else {
     Map::iterator last = --dirs_.end();
     logical = last->first;
 
     if (!increment(logical)) {
       throw std::runtime_error("out of range for create_next_dir");
     }
   }
 
   return make_new_subdir(logical);
 }

◆ create_next_file()

File::Ptr OpenDDS::FileSystemStorage::Directory::create_next_file ( )

assumes all files in this dir are created with this API

Definition at line 574 of file FileSystemStorage.cpp.

References ACE_String_Base< char >::end().

 {
   ACE_TString logical;
 
   if (files_.empty()) {
     logical = FSS_DEFAULT_FILE_NAME;
 
   } else {
     Map::iterator last = --files_.end();
     logical = last->first;
 
     if (!increment(logical)) {
       throw std::runtime_error("out of range for create_next_file");
     }
   }
 
   return make_new_file(logical);
 }

◆ end_dirs()

Directory::DirectoryIterator OpenDDS::FileSystemStorage::Directory::end_dirs ( )

Definition at line 598 of file FileSystemStorage.cpp.

References OpenDDS::DCPS::rchandle_from().

 {
   return DirectoryIterator(dirs_.end(),  rchandle_from(this));
 }

◆ end_files()

Directory::FileIterator OpenDDS::FileSystemStorage::Directory::end_files ( )

Definition at line 532 of file FileSystemStorage.cpp.

References OpenDDS::DCPS::rchandle_from().

 {
   return FileIterator(files_.end(),  rchandle_from(this));
 }

◆ full_path()

ACE_TString OpenDDS::FileSystemStorage::Directory::full_path ( const ACE_TString & relative ) const

private

Definition at line 522 of file FileSystemStorage.cpp.

 {
   return physical_dirname_ + relative;
 }

◆ get_dir()

Directory::Ptr OpenDDS::FileSystemStorage::Directory::get_dir ( const OPENDDS_VECTOR(OPENDDS_STRING)& path )

Definition at line 603 of file FileSystemStorage.cpp.

References OPENDDS_STRING, OPENDDS_VECTOR, and OpenDDS::DCPS::rchandle_from().

 {
   Directory::Ptr dir = rchandle_from(this);
   typedef OPENDDS_VECTOR(OPENDDS_STRING)::const_iterator iterator;
 
   for (iterator iter = path.begin(), end = path.end(); iter != end; ++iter) {
     dir = dir->get_subdir(iter->c_str());
   }
 
   return dir;
 }

◆ get_file()

File::Ptr OpenDDS::FileSystemStorage::Directory::get_file ( const char * name )

Definition at line 537 of file FileSystemStorage.cpp.

References ACE_TEXT_CHAR_TO_TCHAR, and OpenDDS::DCPS::rchandle_from().

 {
   if (std::strlen(name) >= FSS_MAX_FILE_NAME) {
     throw std::runtime_error("file name too long");
   }
 
   ACE_TString t_name(ACE_TEXT_CHAR_TO_TCHAR(name));
   Map::iterator it = files_.find(t_name);
 
   if (it == files_.end()) {
     return make_new_file(t_name);
 
   } else {
     return DCPS::make_rch<File>(full_path(it->second), it->first, rchandle_from(this));
   }
 }

◆ get_subdir()

Directory::Ptr OpenDDS::FileSystemStorage::Directory::get_subdir ( const char * name )

Definition at line 615 of file FileSystemStorage.cpp.

References ACE_TEXT_CHAR_TO_TCHAR, and OpenDDS::DCPS::rchandle_from().

 {
   ACE_TString t_name = ACE_TEXT_CHAR_TO_TCHAR(name);
   Map::iterator it = dirs_.find(t_name);
 
   if (it == dirs_.end()) {
     return make_new_subdir(t_name);
 
   } else {
     return DCPS::make_rch<Directory>(full_path(it->second), it->first,  rchandle_from(this));
   }
 }

◆ make_new_file()

File::Ptr OpenDDS::FileSystemStorage::Directory::make_new_file ( const ACE_TString & t_name )

private

Definition at line 554 of file FileSystemStorage.cpp.

References ACE_TEXT_ALWAYS_CHAR, OpenDDS::FileSystemStorage::b32h_encode(), ACE_String_Base< char >::c_str(), and OpenDDS::DCPS::rchandle_from().

 {
   if (dirs_.find(t_name) != dirs_.end()) {
     throw std::runtime_error("Can't create a file with the same name as "
                              "an existing directory.");
   }
 
   ACE_TString phys = add_entry() + b32h_encode(t_name.c_str());
   files_[t_name] = phys;
 
   CwdGuard cg(physical_dirname_);
   // touch the file since the user has asked to create it
   std::FILE* fh = std::fopen(ACE_TEXT_ALWAYS_CHAR(phys.c_str()), "w");
 
   if (!fh) throw std::runtime_error("Can't create the file");
 
   std::fclose(fh);
   return DCPS::make_rch<File>(physical_dirname_ + phys, t_name,  rchandle_from(this));
 }

◆ make_new_subdir()

Directory::Ptr OpenDDS::FileSystemStorage::Directory::make_new_subdir ( const ACE_TString & logical )

private

Definition at line 647 of file FileSystemStorage.cpp.

References ACE_TEXT(), OpenDDS::FileSystemStorage::b32h_encode(), ACE_String_Base< char >::c_str(), ACE_String_Base< char >::length(), OpenDDS::DCPS::rchandle_from(), ACE_OS::snprintf(), and ACE_String_Base< char >::substr().

 {
   if (files_.find(t_name) != files_.end()) {
     throw std::runtime_error("Can't create a directory with the same "
                              "name as an existing file.");
   }
 
   ACE_TString logical(t_name.c_str(),
                       (std::min)(FSS_MAX_FILE_NAME, t_name.length()));
   ACE_TString phys_prefix = add_entry();
   ACE_TString phys_base = b32h_encode(logical.c_str());
 
   if (t_name.length() >= FSS_MAX_FILE_NAME) {
     unsigned int& counter = long_names_[phys_prefix + phys_base];
 
     if (counter == 99999) {
       throw std::runtime_error("Long directory name out of range");
     }
 
     phys_base += ACE_TEXT(".     X"); // snprintf will clobber the X with a 0
     ACE_TCHAR* buf = &phys_base[0] + phys_base.length() - 6;
     ACE_OS::snprintf(buf, 6, ACE_TEXT("%05u"), counter++);
     phys_base = phys_base.substr(0, phys_base.length() - 1); // trim the 0
   }
 
   ACE_TString phys = phys_prefix + phys_base;
   dirs_[t_name] = phys;
   {
     CwdGuard cg(physical_dirname_);
 
     if (dds_mkdir(phys.c_str()) == -1) {
       throw std::runtime_error("Can't create directory");
     }
 
     if ((phys_prefix.length() > 0 && dds_chdir(phys_prefix.c_str()) == -1)
         || dds_chdir(phys_base.c_str()) == -1) {
       dds_rmdir(phys.c_str());
       throw std::runtime_error("Can't change to newly created directory");
     }
 
     std::ofstream fn("_fullname");
     fn << t_name << '\n';
   }
   return DCPS::make_rch<Directory>(physical_dirname_ + phys, t_name,  rchandle_from(this));
 }

◆ name()

OPENDDS_STRING OpenDDS::FileSystemStorage::Directory::name ( void ) const

Definition at line 754 of file FileSystemStorage.cpp.

References ACE_TEXT_ALWAYS_CHAR.

 {
   return ACE_TEXT_ALWAYS_CHAR(logical_dirname_.c_str());
 }

◆ OPENDDS_MAP() [1/3]

typedef OpenDDS::FileSystemStorage::Directory::OPENDDS_MAP	(	ACE_TString	,
		ACE_TString
	)

private

◆ OPENDDS_MAP() [2/3]

OpenDDS::FileSystemStorage::Directory::OPENDDS_MAP	(	unsigned	int,
		unsigned	int
	)

private

◆ OPENDDS_MAP() [3/3]

OpenDDS::FileSystemStorage::Directory::OPENDDS_MAP	(	ACE_TString	,
		unsigned	int
	)

private

◆ parent()

Directory::Ptr OpenDDS::FileSystemStorage::Directory::parent ( void ) const

inline

Definition at line 195 of file FileSystemStorage.h.

                               {
     return parent_;
   }

◆ remove()

void OpenDDS::FileSystemStorage::Directory::remove ( void )

Definition at line 742 of file FileSystemStorage.cpp.

References OpenDDS::DCPS::RcHandle< T >::is_nil(), OpenDDS::FileSystemStorage::File::parent_, and OpenDDS::DCPS::RcHandle< T >::reset().

 {
   if (!parent_.is_nil()) parent_->removing(logical_dirname_, false);
 
   parent_.reset();
   recursive_remove(physical_dirname_);
   overflow_.clear();
   files_.clear();
   dirs_.clear();
   long_names_.clear();
 }

◆ removing()

void OpenDDS::FileSystemStorage::Directory::removing	(	const ACE_TString &	logical_child,
		bool	file
	)

private

Definition at line 847 of file FileSystemStorage.cpp.

References ACE_TEXT(), ACE_OS::atoi(), ACE_String_Base< char >::c_str(), dirs_, files_, ACE_String_Base< char >::find(), and physical_dirname_.

 {
   Map& m = file ? files_ : dirs_;
   Map::iterator iter = m.find(child);
 
   if (iter == m.end()) return;
 
   const ACE_TString& phys = iter->second;
   String_Index_t idx = phys.find(ACE_TEXT("_overflow."));
   unsigned int bucket = (idx == 0 ? ACE_OS::atoi(&phys[idx + 10]) : 0);
 
   if (--overflow_[bucket] == 0 && bucket > 0) {
     overflow_.erase(bucket);
     idx = phys.find(ACE_TEXT('/'));
     ACE_TString ov_dir = physical_dirname_ + ACE_TString(phys.c_str(), idx);
     dds_rmdir(ov_dir.c_str());
   }
 
   m.erase(iter);
 }

◆ scan_dir()

void OpenDDS::FileSystemStorage::Directory::scan_dir	(	const ACE_TString &	relative,
		DDS_Dirent &	dir,
		unsigned int	overflow_index
	)

private

Definition at line 784 of file FileSystemStorage.cpp.

References ACE_TEXT(), ACE_TEXT_CHAR_TO_TCHAR, ACE_OS::atoi(), OpenDDS::FileSystemStorage::b32h_decode(), ACE_String_Base< char >::c_str(), DDS_DIRENT, DDS_Dirent, dirs_, files_, ACE_String_Base_Const::npos, OPENDDS_STRING, physical_dirname_, ACE_String_Base< char >::rfind(), ACE_OS::strlen(), and ACE_OS::strncmp().

Referenced by Directory().

 {
   ACE_TString path = physical_dirname_ + relative;
   add_slash(path);
 
   while (DDS_DIRENT* ent = dir.read()) {
     if (ent->d_name[0] == ACE_TEXT('.') && (!ent->d_name[1] ||
         (ent->d_name[1] == ACE_TEXT('.') && !ent->d_name[2]))) {
       continue; // skip '.' and '..'
     }
 
     ACE_TString file = path + ent->d_name;
 
     if (is_dir(file.c_str())) {
       ACE_TString phys(relative);
       add_slash(phys);
       phys += ent->d_name;
 
       if (ACE_OS::strncmp(ent->d_name, ACE_TEXT("_overflow."), 10) == 0) {
         unsigned int n = ACE_OS::atoi(ent->d_name + 10);
         DDS_Dirent overflow(file.c_str());
         scan_dir(ent->d_name, overflow, n);
 
       } else if (ACE_OS::strlen(ent->d_name) <= FSS_MAX_FILE_NAME_ENCODED) {
         dirs_[b32h_decode(ent->d_name)] = phys;
         ++overflow_[overflow_index];
 
       } else {
         CwdGuard cg(file);
         std::ifstream fn("_fullname");
         OPENDDS_STRING fullname;
 
         if (!std::getline(fn, fullname)) {
           throw std::runtime_error("Can't read .../_fullname");
         }
 
         ACE_TString full_t(ACE_TEXT_CHAR_TO_TCHAR(fullname.c_str()));
         dirs_[full_t] = phys;
         ++overflow_[overflow_index];
 
         String_Index_t idx = phys.rfind(ACE_TEXT('.'));
 
         if (idx == ACE_TString::npos) {
           throw std::runtime_error("Badly formatted long dir name");
         }
 
         ACE_TString prefix(phys.c_str(), idx);
         unsigned int serial = ACE_OS::atoi(&phys[idx + 1]);
         unsigned int& counter = long_names_[prefix];
 
         if (serial >= counter) counter = serial + 1;
       }
 
     } else { // regular file
       if (ent->d_name[0] != ACE_TEXT('_')) {
         files_[b32h_decode(ent->d_name)] = ent->d_name;
         ++overflow_[overflow_index];
       }
     }
   }
 }

Friends And Related Function Documentation

◆ File

friend class File

friend

Definition at line 200 of file FileSystemStorage.h.

◆ OpenDDS::DCPS::make_rch

template<typename T , typename U0 , typename U1 , typename U2 >

RcHandle<T> OpenDDS::DCPS::make_rch	(	const U0 &	,
		const U1 &	,
		const U2 &
	)

friend

Member Data Documentation

◆ dirs_

Map OpenDDS::FileSystemStorage::Directory::dirs_

private

Definition at line 219 of file FileSystemStorage.h.

Referenced by removing(), and scan_dir().

◆ files_

Map OpenDDS::FileSystemStorage::Directory::files_

private

Definition at line 219 of file FileSystemStorage.h.

Referenced by removing(), and scan_dir().

◆ logical_dirname_

ACE_TString OpenDDS::FileSystemStorage::Directory::logical_dirname_

private

Definition at line 214 of file FileSystemStorage.h.

◆ parent_

Directory::Ptr OpenDDS::FileSystemStorage::Directory::parent_

private

Definition at line 213 of file FileSystemStorage.h.

◆ physical_dirname_

ACE_TString OpenDDS::FileSystemStorage::Directory::physical_dirname_

private

Definition at line 214 of file FileSystemStorage.h.

Referenced by Directory(), removing(), and scan_dir().

The documentation for this class was generated from the following files:

Classes

Public Types

Public Member Functions

Static Public Member Functions

Private Member Functions

Private Attributes

Friends

Additional Inherited Members

Detailed Description

Member Typedef Documentation

◆ DirectoryIterator

◆ FileIterator

◆ Ptr

Constructor & Destructor Documentation

◆ Directory()

Member Function Documentation

◆ add_entry()

◆ begin_dirs()

◆ begin_files()

◆ create()

◆ create_next_dir()

◆ create_next_file()

◆ end_dirs()

◆ end_files()

◆ full_path()

◆ get_dir()

◆ get_file()

◆ get_subdir()

◆ make_new_file()

◆ make_new_subdir()

◆ name()

◆ OPENDDS_MAP() [1/3]

◆ OPENDDS_MAP() [2/3]

◆ OPENDDS_MAP() [3/3]

◆ parent()

◆ remove()

◆ removing()

◆ scan_dir()

Friends And Related Function Documentation

◆ File

◆ OpenDDS::DCPS::make_rch

Member Data Documentation

◆ dirs_

◆ files_

◆ logical_dirname_

◆ parent_

◆ physical_dirname_