Rename internal lock/unlock APIs

henrygab · henrygab · commit 76987ca28ed4 · 2020-01-06T08:36:08.000-08:00
diff --git a/libraries/Adafruit_LittleFS/src/Adafruit_LittleFS.h b/libraries/Adafruit_LittleFS/src/Adafruit_LittleFS.h
@@ -78,8 +78,8 @@ class Adafruit_LittleFS
     lfs_t _lfs;
 
     // these two functions need access to the private _mutex variable:
-    friend void Adafruit_LittleFS_Namespace::File::DoNotCallFromOutsideClass_LockFilesystem(void);
-    friend void Adafruit_LittleFS_Namespace::File::DoNotCallFromOutsideClass_UnlockFilesystem(void);
+    friend void Adafruit_LittleFS_Namespace::File::_LockFilesystem(void);
+    friend void Adafruit_LittleFS_Namespace::File::_UnlockFilesystem(void);
     //static_assert(configSUPPORT_STATIC_ALLOCATION == 1, "Currently only supports configuration with STATIC_ALLOCATION enabled");
     SemaphoreHandle_t _mutex;
 
diff --git a/libraries/Adafruit_LittleFS/src/Adafruit_LittleFS_File.cpp b/libraries/Adafruit_LittleFS/src/Adafruit_LittleFS_File.cpp
@@ -103,9 +103,9 @@ bool File::_open_dir (char const *filepath)
 bool File::open (char const *filepath, uint8_t mode)
 {
   bool ret = false;
-  this->DoNotCallFromOutsideClass_LockFilesystem();
+  this->_LockFilesystem();
   ret = this->_open(filepath, mode);
-  this->DoNotCallFromOutsideClass_UnlockFilesystem();
+  this->_UnlockFilesystem();
   return ret;
 }
 bool File::_open (char const *filepath, uint8_t mode)
@@ -150,7 +150,7 @@ size_t File::write (uint8_t ch)
 size_t File::write (uint8_t const *buf, size_t size)
 {
   lfs_ssize_t wrcount = 0;
-  this->DoNotCallFromOutsideClass_LockFilesystem();
+  this->_LockFilesystem();
   if (!this->_is_dir)
   {
     wrcount = lfs_file_write(_fs->getFS(), _file, buf, size);
@@ -159,7 +159,7 @@ size_t File::write (uint8_t const *buf, size_t size)
       wrcount = 0;
     };
   }
-  this->DoNotCallFromOutsideClass_UnlockFilesystem();
+  this->_UnlockFilesystem();
   return wrcount;
 }
 
@@ -178,19 +178,19 @@ int File::read (void)
 int File::read (void *buf, uint16_t nbyte)
 {
   int ret = 0;
-  this->DoNotCallFromOutsideClass_LockFilesystem();
+  this->_LockFilesystem();
   if (!this->_is_dir)
   {
     ret = lfs_file_read(_fs->getFS(), _file, buf, nbyte);
   }
-  this->DoNotCallFromOutsideClass_UnlockFilesystem();
+  this->_UnlockFilesystem();
   return ret;
 }
 
 int File::peek (void)
 {
   int ret = -1;
-  this->DoNotCallFromOutsideClass_LockFilesystem();
+  this->_LockFilesystem();
   if (!this->_is_dir)
   {
     uint32_t pos = lfs_file_tell(_fs->getFS(), _file);
@@ -201,77 +201,77 @@ int File::peek (void)
     }
     (void)lfs_file_seek(_fs->getFS(), _file, pos, LFS_SEEK_SET);
   }
-  this->DoNotCallFromOutsideClass_UnlockFilesystem();
+  this->_UnlockFilesystem();
   return ret;
 }
 
 int File::available (void)
 {
   int ret = 0;
-  this->DoNotCallFromOutsideClass_LockFilesystem();
+  this->_LockFilesystem();
   if (!this->_is_dir)
   {
     uint32_t size = lfs_file_size(_fs->getFS(), _file);
     uint32_t pos  = lfs_file_tell(_fs->getFS(), _file);
     ret = size - pos;
   }
-  this->DoNotCallFromOutsideClass_UnlockFilesystem();
+  this->_UnlockFilesystem();
   return ret;
 }
 
 bool File::seek (uint32_t pos)
 {
   bool ret = false;
-  this->DoNotCallFromOutsideClass_LockFilesystem();
+  this->_LockFilesystem();
   if (!this->_is_dir)
   {
     ret = lfs_file_seek(_fs->getFS(), _file, pos, LFS_SEEK_SET) >= 0;
   }
-  this->DoNotCallFromOutsideClass_UnlockFilesystem();
+  this->_UnlockFilesystem();
   return ret;
 }
 
 uint32_t File::position (void)
 {
   uint32_t ret = 0;
-  this->DoNotCallFromOutsideClass_LockFilesystem();
+  this->_LockFilesystem();
   if (!this->_is_dir)
   {
     ret = lfs_file_tell(_fs->getFS(), _file);
   }
-  this->DoNotCallFromOutsideClass_UnlockFilesystem();
+  this->_UnlockFilesystem();
   return ret;
 }
 
 uint32_t File::size (void)
 {
   uint32_t ret = 0;
-  this->DoNotCallFromOutsideClass_LockFilesystem();
+  this->_LockFilesystem();
   if (!this->_is_dir)
   {
     ret = lfs_file_size(_fs->getFS(), _file);
   }
-  this->DoNotCallFromOutsideClass_UnlockFilesystem();
+  this->_UnlockFilesystem();
   return ret;
 
 }
 
 void File::flush (void)
 {
-  this->DoNotCallFromOutsideClass_LockFilesystem();
+  this->_LockFilesystem();
   if (!this->_is_dir)
   {
     lfs_file_sync(_fs->getFS(), _file);
   }
-  this->DoNotCallFromOutsideClass_UnlockFilesystem();
+  this->_UnlockFilesystem();
   return;
 }
 
 void File::close (void)
 {
-  this->DoNotCallFromOutsideClass_LockFilesystem();
+  this->_LockFilesystem();
   this->_close();
-  this->DoNotCallFromOutsideClass_UnlockFilesystem();
+  this->_UnlockFilesystem();
 }
 void File::_close(void)
 {
@@ -302,9 +302,9 @@ File::operator bool (void)
 bool File::isOpen(void)
 {
   bool ret = 0;
-  this->DoNotCallFromOutsideClass_LockFilesystem();
+  this->_LockFilesystem();
   ret = this->_isOpen();
-  this->DoNotCallFromOutsideClass_UnlockFilesystem();
+  this->_UnlockFilesystem();
   return ret;
 }
 bool File::_isOpen(void)
@@ -319,24 +319,24 @@ bool File::_isOpen(void)
 //            suddenly (unexpectedly?) have different values.
 char const* File::name (void)
 {
-  this->DoNotCallFromOutsideClass_LockFilesystem();
+  this->_LockFilesystem();
   char const* ret = this->_name;
-  this->DoNotCallFromOutsideClass_UnlockFilesystem();
+  this->_UnlockFilesystem();
   return ret;
 }
 
 bool File::isDirectory (void)
 {
-  this->DoNotCallFromOutsideClass_LockFilesystem();
+  this->_LockFilesystem();
   bool ret = this->_is_dir;
-  this->DoNotCallFromOutsideClass_UnlockFilesystem();
+  this->_UnlockFilesystem();
   return ret;
 
 }
 
 File File::openNextFile (uint8_t mode)
 {
-  this->DoNotCallFromOutsideClass_LockFilesystem();
+  this->_LockFilesystem();
 
   File ret(*_fs);
   if (this->_is_dir)
@@ -366,26 +366,26 @@ File File::openNextFile (uint8_t mode)
       PRINT_LFS_ERR(rc);
     }
   }
-  this->DoNotCallFromOutsideClass_UnlockFilesystem();
+  this->_UnlockFilesystem();
   return ret;
 }
 
 void File::rewindDirectory (void)
 {
-  this->DoNotCallFromOutsideClass_LockFilesystem();
+  this->_LockFilesystem();
   if (this->_is_dir)
   {
     lfs_dir_rewind(_fs->getFS(), _dir);
   }
-  this->DoNotCallFromOutsideClass_UnlockFilesystem();
+  this->_UnlockFilesystem();
   return;
 }
 
-void File::DoNotCallFromOutsideClass_LockFilesystem(void)
+void File::_LockFilesystem(void)
 {
   xSemaphoreTake(this->_fs->_mutex,  portMAX_DELAY);
 }
-void File::DoNotCallFromOutsideClass_UnlockFilesystem(void)
+void File::_UnlockFilesystem(void)
 {
   xSemaphoreGive(this->_fs->_mutex);
 }
diff --git a/libraries/Adafruit_LittleFS/src/Adafruit_LittleFS_File.h b/libraries/Adafruit_LittleFS/src/Adafruit_LittleFS_File.h
@@ -82,8 +82,8 @@ class File : public Stream
     void rewindDirectory (void);
 
     // Has to be public, in order to grant 'friend' permissions to Adafruit_LittleFS private member _mutex
-    void DoNotCallFromOutsideClass_LockFilesystem(void);
-    void DoNotCallFromOutsideClass_UnlockFilesystem(void);
+    void _LockFilesystem(void);
+    void _UnlockFilesystem(void);
 
   private:
     Adafruit_LittleFS* _fs;

Original file line number	Diff line number	Diff line change
`@@ -103,9 +103,9 @@ bool File::_open_dir (char const *filepath)`
`103`	`103`	`bool File::open (char const *filepath, uint8_t mode)`
`104`	`104`	`{`
`105`	`105`	`bool ret = false;`
`106`		`- this->DoNotCallFromOutsideClass_LockFilesystem();`
	`106`	`+ this->_LockFilesystem();`
`107`	`107`	`ret = this->_open(filepath, mode);`
`108`		`- this->DoNotCallFromOutsideClass_UnlockFilesystem();`
	`108`	`+ this->_UnlockFilesystem();`
`109`	`109`	`return ret;`
`110`	`110`	`}`
`111`	`111`	`bool File::_open (char const *filepath, uint8_t mode)`
`@@ -150,7 +150,7 @@ size_t File::write (uint8_t ch)`
`150`	`150`	`size_t File::write (uint8_t const *buf, size_t size)`
`151`	`151`	`{`
`152`	`152`	`lfs_ssize_t wrcount = 0;`
`153`		`- this->DoNotCallFromOutsideClass_LockFilesystem();`
	`153`	`+ this->_LockFilesystem();`
`154`	`154`	`if (!this->_is_dir)`
`155`	`155`	`{`
`156`	`156`	`wrcount = lfs_file_write(_fs->getFS(), _file, buf, size);`
`@@ -159,7 +159,7 @@ size_t File::write (uint8_t const *buf, size_t size)`
`159`	`159`	`wrcount = 0;`
`160`	`160`	`};`
`161`	`161`	`}`
`162`		`- this->DoNotCallFromOutsideClass_UnlockFilesystem();`
	`162`	`+ this->_UnlockFilesystem();`
`163`	`163`	`return wrcount;`
`164`	`164`	`}`
`165`	`165`
`@@ -178,19 +178,19 @@ int File::read (void)`
`178`	`178`	`int File::read (void *buf, uint16_t nbyte)`
`179`	`179`	`{`
`180`	`180`	`int ret = 0;`
`181`		`- this->DoNotCallFromOutsideClass_LockFilesystem();`
	`181`	`+ this->_LockFilesystem();`
`182`	`182`	`if (!this->_is_dir)`
`183`	`183`	`{`
`184`	`184`	`ret = lfs_file_read(_fs->getFS(), _file, buf, nbyte);`
`185`	`185`	`}`
`186`		`- this->DoNotCallFromOutsideClass_UnlockFilesystem();`
	`186`	`+ this->_UnlockFilesystem();`
`187`	`187`	`return ret;`
`188`	`188`	`}`
`189`	`189`
`190`	`190`	`int File::peek (void)`
`191`	`191`	`{`
`192`	`192`	`int ret = -1;`
`193`		`- this->DoNotCallFromOutsideClass_LockFilesystem();`
	`193`	`+ this->_LockFilesystem();`
`194`	`194`	`if (!this->_is_dir)`
`195`	`195`	`{`
`196`	`196`	`uint32_t pos = lfs_file_tell(_fs->getFS(), _file);`
`@@ -201,77 +201,77 @@ int File::peek (void)`
`201`	`201`	`}`
`202`	`202`	`(void)lfs_file_seek(_fs->getFS(), _file, pos, LFS_SEEK_SET);`
`203`	`203`	`}`
`204`		`- this->DoNotCallFromOutsideClass_UnlockFilesystem();`
	`204`	`+ this->_UnlockFilesystem();`
`205`	`205`	`return ret;`
`206`	`206`	`}`
`207`	`207`
`208`	`208`	`int File::available (void)`
`209`	`209`	`{`
`210`	`210`	`int ret = 0;`
`211`		`- this->DoNotCallFromOutsideClass_LockFilesystem();`
	`211`	`+ this->_LockFilesystem();`
`212`	`212`	`if (!this->_is_dir)`
`213`	`213`	`{`
`214`	`214`	`uint32_t size = lfs_file_size(_fs->getFS(), _file);`
`215`	`215`	`uint32_t pos = lfs_file_tell(_fs->getFS(), _file);`
`216`	`216`	`ret = size - pos;`
`217`	`217`	`}`
`218`		`- this->DoNotCallFromOutsideClass_UnlockFilesystem();`
	`218`	`+ this->_UnlockFilesystem();`
`219`	`219`	`return ret;`
`220`	`220`	`}`
`221`	`221`
`222`	`222`	`bool File::seek (uint32_t pos)`
`223`	`223`	`{`
`224`	`224`	`bool ret = false;`
`225`		`- this->DoNotCallFromOutsideClass_LockFilesystem();`
	`225`	`+ this->_LockFilesystem();`
`226`	`226`	`if (!this->_is_dir)`
`227`	`227`	`{`
`228`	`228`	`ret = lfs_file_seek(_fs->getFS(), _file, pos, LFS_SEEK_SET) >= 0;`
`229`	`229`	`}`
`230`		`- this->DoNotCallFromOutsideClass_UnlockFilesystem();`
	`230`	`+ this->_UnlockFilesystem();`
`231`	`231`	`return ret;`
`232`	`232`	`}`
`233`	`233`
`234`	`234`	`uint32_t File::position (void)`
`235`	`235`	`{`
`236`	`236`	`uint32_t ret = 0;`
`237`		`- this->DoNotCallFromOutsideClass_LockFilesystem();`
	`237`	`+ this->_LockFilesystem();`
`238`	`238`	`if (!this->_is_dir)`
`239`	`239`	`{`
`240`	`240`	`ret = lfs_file_tell(_fs->getFS(), _file);`
`241`	`241`	`}`
`242`		`- this->DoNotCallFromOutsideClass_UnlockFilesystem();`
	`242`	`+ this->_UnlockFilesystem();`
`243`	`243`	`return ret;`
`244`	`244`	`}`
`245`	`245`
`246`	`246`	`uint32_t File::size (void)`
`247`	`247`	`{`
`248`	`248`	`uint32_t ret = 0;`
`249`		`- this->DoNotCallFromOutsideClass_LockFilesystem();`
	`249`	`+ this->_LockFilesystem();`
`250`	`250`	`if (!this->_is_dir)`
`251`	`251`	`{`
`252`	`252`	`ret = lfs_file_size(_fs->getFS(), _file);`
`253`	`253`	`}`
`254`		`- this->DoNotCallFromOutsideClass_UnlockFilesystem();`
	`254`	`+ this->_UnlockFilesystem();`
`255`	`255`	`return ret;`
`256`	`256`
`257`	`257`	`}`
`258`	`258`
`259`	`259`	`void File::flush (void)`
`260`	`260`	`{`
`261`		`- this->DoNotCallFromOutsideClass_LockFilesystem();`
	`261`	`+ this->_LockFilesystem();`
`262`	`262`	`if (!this->_is_dir)`
`263`	`263`	`{`
`264`	`264`	`lfs_file_sync(_fs->getFS(), _file);`
`265`	`265`	`}`
`266`		`- this->DoNotCallFromOutsideClass_UnlockFilesystem();`
	`266`	`+ this->_UnlockFilesystem();`
`267`	`267`	`return;`
`268`	`268`	`}`
`269`	`269`
`270`	`270`	`void File::close (void)`
`271`	`271`	`{`
`272`		`- this->DoNotCallFromOutsideClass_LockFilesystem();`
	`272`	`+ this->_LockFilesystem();`
`273`	`273`	`this->_close();`
`274`		`- this->DoNotCallFromOutsideClass_UnlockFilesystem();`
	`274`	`+ this->_UnlockFilesystem();`
`275`	`275`	`}`
`276`	`276`	`void File::_close(void)`
`277`	`277`	`{`
`@@ -302,9 +302,9 @@ File::operator bool (void)`
`302`	`302`	`bool File::isOpen(void)`
`303`	`303`	`{`
`304`	`304`	`bool ret = 0;`
`305`		`- this->DoNotCallFromOutsideClass_LockFilesystem();`
	`305`	`+ this->_LockFilesystem();`
`306`	`306`	`ret = this->_isOpen();`
`307`		`- this->DoNotCallFromOutsideClass_UnlockFilesystem();`
	`307`	`+ this->_UnlockFilesystem();`
`308`	`308`	`return ret;`
`309`	`309`	`}`
`310`	`310`	`bool File::_isOpen(void)`
`@@ -319,24 +319,24 @@ bool File::_isOpen(void)`
`319`	`319`	`// suddenly (unexpectedly?) have different values.`
`320`	`320`	`char const* File::name (void)`
`321`	`321`	`{`
`322`		`- this->DoNotCallFromOutsideClass_LockFilesystem();`
	`322`	`+ this->_LockFilesystem();`
`323`	`323`	`char const* ret = this->_name;`
`324`		`- this->DoNotCallFromOutsideClass_UnlockFilesystem();`
	`324`	`+ this->_UnlockFilesystem();`
`325`	`325`	`return ret;`
`326`	`326`	`}`
`327`	`327`
`328`	`328`	`bool File::isDirectory (void)`
`329`	`329`	`{`
`330`		`- this->DoNotCallFromOutsideClass_LockFilesystem();`
	`330`	`+ this->_LockFilesystem();`
`331`	`331`	`bool ret = this->_is_dir;`
`332`		`- this->DoNotCallFromOutsideClass_UnlockFilesystem();`
	`332`	`+ this->_UnlockFilesystem();`
`333`	`333`	`return ret;`
`334`	`334`
`335`	`335`	`}`
`336`	`336`
`337`	`337`	`File File::openNextFile (uint8_t mode)`
`338`	`338`	`{`
`339`		`- this->DoNotCallFromOutsideClass_LockFilesystem();`
	`339`	`+ this->_LockFilesystem();`
`340`	`340`
`341`	`341`	`File ret(*_fs);`
`342`	`342`	`if (this->_is_dir)`
`@@ -366,26 +366,26 @@ File File::openNextFile (uint8_t mode)`
`366`	`366`	`PRINT_LFS_ERR(rc);`
`367`	`367`	`}`
`368`	`368`	`}`
`369`		`- this->DoNotCallFromOutsideClass_UnlockFilesystem();`
	`369`	`+ this->_UnlockFilesystem();`
`370`	`370`	`return ret;`
`371`	`371`	`}`
`372`	`372`
`373`	`373`	`void File::rewindDirectory (void)`
`374`	`374`	`{`
`375`		`- this->DoNotCallFromOutsideClass_LockFilesystem();`
	`375`	`+ this->_LockFilesystem();`
`376`	`376`	`if (this->_is_dir)`
`377`	`377`	`{`
`378`	`378`	`lfs_dir_rewind(_fs->getFS(), _dir);`
`379`	`379`	`}`
`380`		`- this->DoNotCallFromOutsideClass_UnlockFilesystem();`
	`380`	`+ this->_UnlockFilesystem();`
`381`	`381`	`return;`
`382`	`382`	`}`
`383`	`383`
`384`		`-void File::DoNotCallFromOutsideClass_LockFilesystem(void)`
	`384`	`+void File::_LockFilesystem(void)`
`385`	`385`	`{`
`386`	`386`	`xSemaphoreTake(this->_fs->_mutex, portMAX_DELAY);`
`387`	`387`	`}`
`388`		`-void File::DoNotCallFromOutsideClass_UnlockFilesystem(void)`
	`388`	`+void File::_UnlockFilesystem(void)`
`389`	`389`	`{`
`390`	`390`	`xSemaphoreGive(this->_fs->_mutex);`
`391`	`391`	`}`