SdBaseFile Class Reference

Base class for SdFile with Print and C++ streams. More...

#include <SdBaseFile.h>

Inheritance diagram for SdBaseFile:

Collaboration diagram for SdBaseFile:

Public Member Functions
	SdBaseFile ()
	SdBaseFile (const char *path, uint8_t oflag)
	~SdBaseFile ()
void	getpos (filepos_t *pos)
void	setpos (filepos_t *pos)
bool	close ()
bool	contiguousRange (uint32_t *bgnBlock, uint32_t *endBlock)
bool	createContiguous (SdBaseFile *dirFile, const char *path, uint32_t size)
uint32_t	curCluster () const
uint32_t	curPosition () const
bool	dirEntry (dir_t *dir)
bool	exists (const char *name)
int16_t	fgets (char *str, int16_t num, char *delim=0)
uint32_t	fileSize () const
uint32_t	firstCluster () const
bool	isDir () const
bool	isFile () const
bool	isOpen () const
bool	isSubDir () const
bool	isRoot () const
bool	getDosName (char *const name)
void	ls (uint8_t flags=0, uint8_t indent=0)
bool	mkdir (SdBaseFile *dir, const char *path, bool pFlag=true)
bool	open (SdBaseFile *dirFile, uint16_t index, uint8_t oflag)
bool	open (SdBaseFile *dirFile, const char *path, uint8_t oflag)
bool	open (const char *path, uint8_t oflag=O_READ)
bool	openNext (SdBaseFile *dirFile, uint8_t oflag)
bool	openRoot (SdVolume *vol)
int	peek ()
bool	printName ()
int16_t	read ()
int16_t	read (void *buf, uint16_t nbyte)
int8_t	readDir (dir_t *dir, char *longFilename)
bool	remove ()
void	rewind ()
bool	rename (SdBaseFile *dirFile, const char *newPath)
bool	rmdir ()
bool	rmRfStar ()
bool	seekCur (const int32_t offset)
bool	seekEnd (const int32_t offset=0)
bool	seekSet (const uint32_t pos)
bool	sync ()
bool	timestamp (SdBaseFile *file)
bool	timestamp (uint8_t flag, uint16_t year, uint8_t month, uint8_t day, uint8_t hour, uint8_t minute, uint8_t second)
uint8_t	type () const
bool	truncate (uint32_t size)
SdVolume *	volume () const
int16_t	write (const void *buf, uint16_t nbyte)

Static Public Member Functions
static SdBaseFile *	cwd ()
static void	dateTimeCallback (void(*dateTime)(uint16_t *date, uint16_t *time))
static void	dateTimeCallbackCancel ()
static void	dirName (const dir_t &dir, char *name)
static void	printFatDate (uint16_t fatDate)
static void	printFatTime (uint16_t fatTime)
static bool	remove (SdBaseFile *dirFile, const char *path)

Public Attributes
bool	writeError

Friends
class	SdFat

Detailed Description

Base class for SdFile with Print and C++ streams.

Constructor & Destructor Documentation

SdBaseFile() [1/2]

SdBaseFile::SdBaseFile

(

)

: writeError(false), type_(FAT_FILE_TYPE_CLOSED) {}

SdBaseFile() [2/2]

SdBaseFile::SdBaseFile	(	const char *	path,
		uint8_t	oflag
	)

~SdBaseFile()

SdBaseFile::~SdBaseFile

(

)

{ if (isOpen()) close(); }

Here is the call graph for this function:

Member Function Documentation

getpos()

void SdBaseFile::getpos

(

filepos_t *

pos

)

get position for streams

Parameters

[out]

pos

struct to receive position

setpos()

void SdBaseFile::setpos

(

filepos_t *

pos

)

set position for streams

Parameters

[out]

pos

struct with value for new position

close()

bool SdBaseFile::close

(

)

                       {
    Slot *slot;
    bool success = false;
 
    if (!isOpen())
        return false;
    switch (type_) {
    case FAT_FILE_TYPE_NORMAL:
        slot = _slot_of(this);
        success = f_close(&slot->file) == FR_OK;
        Slot::free(slot);
        _slot_of(this) = nullptr;
        break;
    case FAT_FILE_TYPE_ROOT_FIXED:
    case FAT_FILE_TYPE_ROOT32:
    case FAT_FILE_TYPE_SUBDIR:
        slot = _slot_of(this);
        success = f_closedir(&slot->directory) == FR_OK;
        Slot::free(slot);
        _slot_of(this) = nullptr;
        break;
    default:
        return false;
    }
 
    type_ = FAT_FILE_TYPE_CLOSED;
    return success;
}

Here is the call graph for this function:

Here is the caller graph for this function:

contiguousRange()

bool SdBaseFile::contiguousRange	(	uint32_t *	bgnBlock,
		uint32_t *	endBlock
	)

createContiguous()

bool SdBaseFile::createContiguous	(	SdBaseFile *	dirFile,
		const char *	path,
		uint32_t	size
	)

curCluster()

uint32_t SdBaseFile::curCluster

(

)

const

Returns

The current cluster number for a file or directory.

{ return curCluster_; }

curPosition()

uint32_t SdBaseFile::curPosition

(

)

const

Returns

The current position for a file or directory.

{ return curPosition_; }

cwd()

static SdBaseFile* SdBaseFile::cwd ( )

static

Returns

Current working directory

{ return cwd_; }

dateTimeCallback()

static void SdBaseFile::dateTimeCallback ( void(*)(uint16_t *date, uint16_t *time)  dateTime )

static

Set the date/time callback function

Parameters

[in]

dateTime

The user's call back function. The callback function is of the form:

void dateTime(uint16_t* date, uint16_t* time) {
  uint16_t year;
  uint8_t month, day, hour, minute, second;
 
  // User gets date and time from GPS or real-time clock here
 
  // return date using FAT_DATE macro to format fields
  *date = FAT_DATE(year, month, day);
 
  // return time using FAT_TIME macro to format fields
  *time = FAT_TIME(hour, minute, second);
}

Sets the function that is called when a file is created or when a file's directory entry is modified by sync(). All timestamps, access, creation, and modify, are set when a file is created. sync() maintains the last access date and last modify date/time.

See the timestamp() function.

                                                      {
    dateTime_ = dateTime;
  }

dateTimeCallbackCancel()

static void SdBaseFile::dateTimeCallbackCancel ( )

static

Cancel the date/time callback function.

{ dateTime_ = 0; }

dirEntry()

bool SdBaseFile::dirEntry

(

dir_t *

dir

)

dirName()

static void SdBaseFile::dirName ( const dir_t &  dir, char *  name  )

static

exists()

bool SdBaseFile::exists

(

const char *

name

)

fgets()

int16_t SdBaseFile::fgets	(	char *	str,
		int16_t	num,
		char *	delim = 0
	)

fileSize()

uint32_t SdBaseFile::fileSize

(

)

const

Returns

The total number of bytes in a file or directory.

{ return fileSize_; }

firstCluster()

uint32_t SdBaseFile::firstCluster

(

)

const

Returns

The first cluster number for a file or directory.

{ return firstCluster_; }

isDir()

bool SdBaseFile::isDir

(

)

const

Returns

True if this is a directory else false.

{ return type_ >= FAT_FILE_TYPE_MIN_DIR; }

Here is the caller graph for this function:

isFile()

bool SdBaseFile::isFile

(

)

const

Returns

True if this is a normal file else false.

{ return type_ == FAT_FILE_TYPE_NORMAL; }

isOpen()

bool SdBaseFile::isOpen

(

)

const

Returns

True if this is an open file/directory else false.

{ return type_ != FAT_FILE_TYPE_CLOSED; }

Here is the caller graph for this function:

isSubDir()

bool SdBaseFile::isSubDir

(

)

const

Returns

True if this is a subdirectory else false.

{ return type_ == FAT_FILE_TYPE_SUBDIR; }

isRoot()

bool SdBaseFile::isRoot

(

)

const

Returns

True if this is the root directory.

{ return type_ == FAT_FILE_TYPE_ROOT_FIXED || type_ == FAT_FILE_TYPE_ROOT32; }

Here is the caller graph for this function:

getDosName()

bool SdBaseFile::getDosName

(

char *const

name

)

                                            {
    if (!isOpen())
        return false;
    if (isRoot()) {
        name[0] = '/';
        name[1] = '\0';
        return true;
    }
    if (isDir()) {
        DIR *pd = &_slot_of(this)->directory;
        fname_from_8_3(name, (char *)pd->fn);
        return true;
    } else {
        // TODO: fix
        bsod("get dos name of a file");
    }
    return false;
}

Here is the call graph for this function:

ls()

void SdBaseFile::ls	(	uint8_t	flags = 0,
		uint8_t	indent = 0
	)

mkdir()

bool SdBaseFile::mkdir	(	SdBaseFile *	dir,
		const char *	path,
		bool	pFlag = true
	)

open() [1/3]

bool SdBaseFile::open	(	SdBaseFile *	dirFile,
		uint16_t	index,
		uint8_t	oflag
	)

open() [2/3]

bool SdBaseFile::open	(	SdBaseFile *	dirFile,
		const char *	path,
		uint8_t	oflag
	)

                                                                      {
    if (!dir || isOpen())
        return false;
 
    // prepare full path
    char fullpath[256] = { 0 };
    if (dir->isRoot()) {
        strcat(fullpath, "/");
        strcat(fullpath, path);
    } else {
        auto dirp = &(_slot_of(dir)->directory);
        f_getdirpath(dirp, fullpath, sizeof(fullpath));
        strcat(fullpath, "/");
        strcat(fullpath, path);
    }
 
    // get file info
    FILINFO nfo;
    if (f_stat(fullpath, &nfo) != FR_OK)
        return false;
 
    if (nfo.fattrib & AM_DIR) {
        auto slot = Slot::allocate(Slot::Directory);
        if (!slot)
            return false;
 
        if (f_opendir(&slot->directory, path) == FR_OK) {
            _slot_of(this) = slot;
            type_ = FAT_FILE_TYPE_SUBDIR;
            curPosition_ = 0;
            fileSize_ = f_size(&slot->directory);
            return true;
        } else {
            Slot::free(slot);
            return false;
        }
    } else {
        auto slot = Slot::allocate(Slot::File);
        if (!slot)
            return false;
 
        BYTE mode = 0;
        if (oflag & O_READ)
            mode |= FA_READ;
        if (oflag & O_WRITE)
            mode |= FA_WRITE;
 
        if (f_open(&slot->file, fullpath, mode) == FR_OK) {
            _slot_of(this) = slot;
            type_ = FAT_FILE_TYPE_NORMAL;
            curPosition_ = 0;
            fileSize_ = f_size(&slot->file);
            return true;
        } else {
            Slot::free(slot);
            return false;
        }
    }
    return true;
}

Here is the call graph for this function:

open() [3/3]

bool SdBaseFile::open	(	const char *	path,
		uint8_t	oflag = O_READ
	)

openNext()

bool SdBaseFile::openNext	(	SdBaseFile *	dirFile,
		uint8_t	oflag
	)

openRoot()

bool SdBaseFile::openRoot

(

SdVolume *

vol

)

peek()

int SdBaseFile::peek

(

)

printFatDate()

static void SdBaseFile::printFatDate ( uint16_t  fatDate )

static

printFatTime()

static void SdBaseFile::printFatTime ( uint16_t  fatTime )

static

printName()

bool SdBaseFile::printName

(

)

read() [1/2]

int16_t SdBaseFile::read

(

void

)

                         {
    if (type_ != FAT_FILE_TYPE_NORMAL)
        return -1;
 
    uint8_t b;
    UINT c;
    if (f_read(&_slot_of(this)->file, &b, 1, &c) != FR_OK)
        return -1;
    curPosition_++;
    return b;
}

Here is the call graph for this function:

read() [2/2]

int16_t SdBaseFile::read	(	void *	buf,
		uint16_t	nbyte
	)

                                                  {
    DBG("NOT IMPLEMENTED: read(...)");
    return 0;
}

readDir()

int8_t SdBaseFile::readDir	(	dir_t *	dir,
		char *	longFilename
	)

                                                         {
    // TODO: cleanup (copied from previous implementation)
    FRESULT res;
    FILINFO nfo;
    char *str;
#if _USE_LFN != 0
    char *altname = nfo.altname;
    char *fname = nfo.fname;
#else
    char *altname = nfo.fname;
    // char* fname = 0;
#endif
    if (longFilename)
        longFilename[0] = '\0';
    while (1) {
        res = f_readdir(&_slot_of(this)->directory, &nfo);
        if (res != FR_OK)
            return -1;
        memset(dir->name, ' ', 11);
        str = strchr(altname, '.');
        if (str) {
            strncpy(((char *)dir->name) + 0, altname, str - altname);
            strncpy(((char *)dir->name) + 8, str + 1, 3);
        } else {
            strncpy(((char *)dir->name) + 0, altname, 8);
        }
        if (dir->name[0] == DIR_NAME_FREE)
            return 0;
        if (dir->name[0] == DIR_NAME_DELETED || dir->name[0] == '.') {
            //          if (longFilename) longFilename[0] = '\0';     //
            // Invalidate erased file long name, if any
            continue;
        }
#if _USE_LFN != 0
        if (longFilename)
            strncpy(longFilename, fname, _MAX_LFN);
#endif
        dir->attributes = nfo.fattrib;
        dir->lastWriteDate = nfo.fdate;
        dir->lastWriteTime = nfo.ftime;
        dir->fileSize = nfo.fsize;
        return sizeof(dir_t);
    }
    return 0;
}

Here is the call graph for this function:

remove() [1/2]

static bool SdBaseFile::remove ( SdBaseFile *  dirFile, const char *  path  )

static

remove() [2/2]

bool SdBaseFile::remove

(

)

rewind()

void SdBaseFile::rewind

(

)

Set the file's current position to zero.

{ seekSet(0); }

Here is the call graph for this function:

rename()

bool SdBaseFile::rename	(	SdBaseFile *	dirFile,
		const char *	newPath
	)

rmdir()

bool SdBaseFile::rmdir

(

)

rmRfStar()

bool SdBaseFile::rmRfStar

(

)

seekCur()

bool SdBaseFile::seekCur

(

const int32_t

offset

)

Set the files position to current position + pos. See seekSet().

Parameters

[in]

offset

The new position in bytes from the current position.

Returns

true for success or false for failure.

{ return seekSet(curPosition_ + offset); }

Here is the call graph for this function:

seekEnd()

bool SdBaseFile::seekEnd

(

const int32_t

offset = 0

)

Set the files position to end-of-file + offset. See seekSet().

Parameters

[in]

offset

The new position in bytes from end-of-file.

Returns

true for success or false for failure.

{ return seekSet(fileSize_ + offset); }

Here is the call graph for this function:

seekSet()

bool SdBaseFile::seekSet

(

const uint32_t

pos

)

                                           {
    if ((pos == 0) && ((type_ == FAT_FILE_TYPE_ROOT_FIXED) || (type_ == FAT_FILE_TYPE_ROOT32) || (type_ == FAT_FILE_TYPE_SUBDIR))) {
        return f_rewinddir(&_slot_of(this)->directory) == FR_OK;
    }
    if (type_ != FAT_FILE_TYPE_NORMAL)
        return false;
    FSIZE_t szf = pos;
    if (f_lseek(&_slot_of(this)->file, szf) != FR_OK)
        return false;
    curPosition_ = pos;
    return true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

sync()

bool SdBaseFile::sync

(

)

timestamp() [1/2]

bool SdBaseFile::timestamp

(

SdBaseFile *

file

)

timestamp() [2/2]

bool SdBaseFile::timestamp	(	uint8_t	flag,
		uint16_t	year,
		uint8_t	month,
		uint8_t	day,
		uint8_t	hour,
		uint8_t	minute,
		uint8_t	second
	)

type()

uint8_t SdBaseFile::type

(

)

const

Type of file. Use isFile() or isDir() instead of type() if possible.

Returns

The file or directory type.

{ return type_; }

truncate()

bool SdBaseFile::truncate

(

uint32_t

size

)

volume()

SdVolume* SdBaseFile::volume

(

)

const

Returns

SdVolume that contains this file.

{ return vol_; }

write()

int16_t SdBaseFile::write	(	const void *	buf,
		uint16_t	nbyte
	)

Friends And Related Function Documentation

SdFat

friend class SdFat

friend

Member Data Documentation

writeError

bool SdBaseFile::writeError

writeError is set to true if an error occurs during a write(). Set writeError to false before calling print() and/or write() and check for true after calls to print() and/or write().