file.cpp

贡献一份commoncpp2,有兴趣的可以研究一下

	}
}

MappedFile::MappedFile(const char *fname, pos_t pos, size_t len, Access mode) :
RandomFile(fname)
{
	fd = open(fname, (int)mode);
	if(fd < 0)
	{
		error(errOpenFailed);
		return;
	}

	switch(mode)
	{
	case O_RDONLY:
		prot = PROT_READ;
		break;
	case O_WRONLY:
		prot = PROT_WRITE;
		break;
	default:
		prot = PROT_READ | PROT_WRITE;
	}

	enterMutex();
	lseek(fd, pos + len, SEEK_SET);
	fcb.address = (caddr_t)mmap(NULL, len, prot, MAP_SHARED, fd, pos);
	fcb.len = len;
	fcb.pos = pos;
	leaveMutex();
	if((caddr_t)(fcb.address) == (caddr_t)(MAP_FAILED))
	{
		close(fd);
		fd = -1;
		error(errMapFailed);
	}
}

MappedFile::~MappedFile()
{
	unlock();
	final();
}

void MappedFile::sync(void)
{
	msync(fcb.address, fcb.len, MS_SYNC);
}

void MappedFile::release(caddr_t address, size_t len)
{
	enterMutex();
	if(address)
		fcb.address = address;

	if(len)
		fcb.len = len;

	if(fcb.locked)
		unlock();

	munmap(fcb.address, fcb.len);
	leaveMutex();
}

caddr_t MappedFile::fetch(off_t pos, size_t len)
{
	enterMutex();
	unlock();
	fcb.len = len;
	fcb.pos = pos;
	lseek(fd, fcb.pos + len, SEEK_SET);
	fcb.address = (caddr_t)mmap(NULL, len, prot, MAP_SHARED, fd, pos);
	leaveMutex();
	return fcb.address;
}

bool MappedFile::lock(void)
{
	unlock();
	if(!mlock(fcb.address, fcb.len))
		fcb.locked = true;
	return fcb.locked;
}

void MappedFile::unlock(void)
{
	if(!fcb.address)
		fcb.locked = false;

	if(!fcb.locked)
		return;

	munlock(fcb.address, fcb.len);
	fcb.locked = false;
}

void MappedFile::update(size_t offset, size_t len)
{
	int mode = MS_ASYNC;
	caddr_t address;

	if(flags.immediate)
		mode = MS_SYNC;

	enterMutex();
	address = fcb.address;
	address += offset;
	if(!len)
		len = fcb.len;
	leaveMutex();
	msync(address, len, mode);
}

void MappedFile::update(caddr_t address, size_t len)
{
	int mode = MS_ASYNC;
	if(flags.immediate)
		mode = MS_SYNC;

	msync(address, len, mode);
}
#endif
#endif // ndef WIN32

time_t lastAccessed(const char *path)
{
#ifdef	WIN32
	__int64 ts;
	WIN32_FILE_ATTRIBUTE_DATA ino;

	if(!GetFileAttributesEx(path, GetFileExInfoStandard, &ino))
		return 0;

	ts = ((__int64)ino.ftLastAccessTime.dwHighDateTime << 32) +
		ino.ftLastAccessTime.dwLowDateTime;

	ts -= (SECS_BETWEEN_EPOCHS * SECS_TO_100NS);
        ts /= SECS_TO_100NS;

        return(time_t)ts;
#else
	struct stat ino;

	if(stat(path, &ino))
		return 0;

	return ino.st_atime;
#endif
}

time_t lastModified(const char *path)
{
#ifdef	WIN32
	__int64 ts;
	WIN32_FILE_ATTRIBUTE_DATA ino;

	if(!GetFileAttributesEx(path, GetFileExInfoStandard, &ino))
		return 0;

	ts = ((__int64)ino.ftLastWriteTime.dwHighDateTime << 32) +
		ino.ftLastWriteTime.dwLowDateTime;

	ts -= (SECS_BETWEEN_EPOCHS * SECS_TO_100NS);
	ts /= SECS_TO_100NS;

	return(time_t)ts;
#else
	struct stat ino;
	
	if(stat(path, &ino))
		return 0;

	return ino.st_mtime;
#endif
}

bool isDir(const char *path)
{
#ifdef WIN32
	DWORD attr = GetFileAttributes(path);
	if(attr == (DWORD)~0l)
		return false;

	if(attr & FILE_ATTRIBUTE_DIRECTORY)
		return true;

	return false;

#else
	struct stat ino;

	if(stat(path, &ino))
		return false;

	if(S_ISDIR(ino.st_mode))
		return true;

	return false;
#endif // WIN32
}

bool isFile(const char *path)
{
#ifdef WIN32
	DWORD attr = GetFileAttributes(path);
	if(attr == (DWORD)~0l)
		return false;

	if(attr & FILE_ATTRIBUTE_DIRECTORY)
		return false;

	return true;

#else
	struct stat ino;

	if(stat(path, &ino))
		return false;

	if(S_ISREG(ino.st_mode))
		return true;

	return false;
#endif // WIN32
}

#ifndef WIN32
// the Win32 version is given in line in the header
bool isDevice(const char *path)
{
	struct stat ino;

	if(stat(path, &ino))
		return false;

	if(S_ISCHR(ino.st_mode))
		return true;

	return false;
}
#endif

bool canAccess(const char *path)
{
#ifdef WIN32
	DWORD attr = GetFileAttributes(path);
	if(attr == (DWORD)~0l)
		return false;

	if(attr & FILE_ATTRIBUTE_SYSTEM)
		return false;

	if(attr & FILE_ATTRIBUTE_HIDDEN)
		return false;

	return true;

#else
	if(!access(path, R_OK))
		return true;

	return false;

#endif
}

bool canModify(const char *path)
{
#ifdef WIN32
	DWORD attr = GetFileAttributes(path);

	if(!canAccess(path))
		return false;

	if(attr & FILE_ATTRIBUTE_READONLY)
		return false;

	if(attr & (FILE_ATTRIBUTE_DIRECTORY | FILE_ATTRIBUTE_NORMAL))
		return true;

	return false;

#else
	if(!access(path, W_OK | R_OK))
		return true;

	return false;
#endif
}

#ifdef	WIN32

const char *File::getExtension(const char *path)
{
        const char *cp = strrchr(path, '\\');
        if(!cp)
                cp = strrchr(path, '/');
        if(!cp)
                cp = strrchr(path, ':');


	if(cp)
		++cp;
	else
		cp = path;

	if(*cp == '.')
		return "";

	cp = strrchr(cp, '.');

	if(!cp)
		cp = "";

	return cp;
}

const char *File::getFilename(const char *path)
{
	const char *cp = strrchr(path, '\\');
	if(cp)
		return ++cp;

	cp = strrchr(path, '/');
	if(cp)
		return ++cp;

	cp = strrchr(path, ':');
	if(cp)
		++cp;

	return path;
}

char *File::getFilename(const char *path, char *buffer, size_t size)
{
	const char *cp = strrchr(path, '\\');
	if(!cp)
		cp = strrchr(path, '/');
	if(!cp)
		cp = strrchr(path, ':');

	if(cp)
		snprintf(buffer, size, "%s", ++cp);
	else
		snprintf(buffer, size, "%s", path);

	return buffer;
}

char *File::getDirname(const char *path, char *buffer, size_t size)
{
	size_t len;
        const char *cp = strrchr(path, '\\');

	snprintf(buffer, size, "%s", path);

        if(!cp)
                cp = strrchr(path, '/');
        if(!cp)
                cp = strrchr(path, ':');

	if(!cp)
		return buffer;

	if(cp)
		len = cp - path;

	if(len >= size)
		len = size - 1;
	buffer[len] = 0;
	return buffer;
}

#else

const char *File::getExtension(const char *path)
{
	const char *cp = strrchr(path, '/');
	if(cp)
		++cp;
	else
		cp = path;

	if(*cp == '.')
		return "";

	cp = strrchr(cp, '.');
	if(cp)
		return cp;
	return "";
}

char *File::getDirname(const char *path, char *buffer, size_t size)
{
        unsigned len;
        const char *cp = strrchr(path, '/');

        snprintf(buffer, size, "%s", path);

        if(!cp)
                return buffer;

        if(cp)
                len = cp - path;

        if(len >= size)
                len = size - 1;
        buffer[len] = 0;
        return buffer;
}

const char *File::getFilename(const char *path)
{
	const char *cp = strrchr(path, '/');

	if(cp)
		return ++cp;

	return path;
}

char *File::getFilename(const char *path, char *buffer, size_t size)
{
	const char *cp = strrchr(path, '/');

	if(cp)
		snprintf(buffer, size, "%s", ++cp);
	else
		snprintf(buffer, size, "%s", path);

	return buffer;
}

#endif

#ifdef	HAVE_REALPATH

char *File::getRealpath(const char *path, char *buffer, size_t size)
{
	char temp[PATH_MAX];
	setString(buffer, size, ".");
	if(!realpath(path, temp))
		return NULL;
	if(strlen(temp) >= size)
		return NULL;
	setString(buffer, size, temp);
	return buffer;
}

#else

#ifdef  WIN323
static char *getFile(char *path)
{
        char *cp = strchr(path, '\\');
        if(!cp)
                cp = strchr(path, '/');
        if(!cp)
                cp = strchr(path, ':');
        return cp;
}
#else
static char *getFile(char *path)
{
	return strchr(path, '/');
}
#endif

char *File::getRealpath(const char *path, char *buffer, size_t size)
{
	if(size > PATH_MAX)
		size = PATH_MAX;

	unsigned symlinks = 0;
#if !defined(DYNAMCIC_LOCAL_ARRAYS)
	char left[PATH_MAX];
#else
	char left[size];
#endif
	size_t left_len, buffer_len;

#ifdef	WIN32
	if(path[1] == ':')
#else
	if(path[0] == '/')
#endif
	{
		buffer[0] = '/';
		buffer[1] = 0;
		if(!path[1])
			return buffer;

		buffer_len = 1;
		snprintf(left, size, "%s", path + 1);
		left_len = strlen(left);
  	}
	else
	{
		if(!Dir::getPrefix(buffer, size))
		{
			snprintf(buffer, size, "%s", ".");
			return NULL;
		}
		buffer_len = strlen(buffer);
		snprintf(left, size, "%s", path);
		left_len = strlen(left);
	}

	if(left_len >= size || buffer_len >= size)
		return NULL;

	while(left_len > 0)
	{
#ifdef	HAVE_LSTAT
		struct stat ino;
#endif
#if !defined(DYNAMIC_LOCAL_ARRAYS)
		char next_token[PATH_MAX];
#else
		char next_token[size];
#endif
		char *p;
		const char *s = (p = getFile(left)) ? p : left + left_len;

		memmove(next_token, left, s - left);
		left_len -= s - left;
		if(p != NULL)
			memmove(left, s + 1, left_len + 1);

		next_token[s - left] = 0;
		if(buffer[buffer_len - 1] != '/')
		{
			if(buffer_len +1 >= size)
				return NULL;

			buffer[buffer_len++] = '/';
			buffer[buffer_len] = 0;
		}
		if(!next_token[0])
			continue;
		else if(!strcmp(next_token, "."))
			continue;
		else if(!strcmp(next_token, ".."))
		{
			if(buffer_len > 1)
			{
				char *q;
				buffer[buffer_len - 1] = 0;
#ifdef	WIN32
				q = strrchr(buffer, '\\');
				if(!q)
					q = strrchr(buffer, '/');
				if(!q)
					q = strchr(buffer, ':');
#else
				q = strrchr(buffer, '/');
#endif
				*q = 0;
				buffer_len = q - buffer;
			}
			continue;
		}
		snprintf(next_token, size, "%s", buffer);
		buffer_len = strlen(buffer);
		if(buffer_len >= size)
			return NULL;

#ifndef	HAVE_LSTAT
		if(!isFile(buffer) && !isDir(buffer))
			return buffer;

		continue;
#else
		if(lstat(buffer, &ino) < 0)
		{
			if(errno == ENOENT && !p)
				return buffer;

			return NULL;
		}

		if((ino.st_mode & S_IFLNK) == S_IFLNK)
		{
                	char symlink[size];
                        int slen;

                        if (symlinks++ > MAXSYMLINKS)
				return NULL;

                        slen = readlink(buffer, symlink, size);

                        if (slen < 0)
                                return NULL;
                        symlink[slen] = 0;

                        if (symlink[0] == '/') 
			{
                                buffer[1] = 0;
                                buffer_len = 1;
                        } else if (buffer_len > 1) 
			{
                                char *q;

				buffer[buffer_len - 1] = 0;
                                q = strrchr(buffer, '/');
                                *q = 0;
                                buffer_len = q - buffer;
                        }
                        if (symlink[slen - 1] != '/' && p) 
			{
                                if (slen >= size)
					return NULL;

                                symlink[slen] = '/';
                                symlink[slen + 1] = 0;
                        }
                        if(p)
			{
				snprintf(symlink, size, "%s", left);
				left_len = strlen(symlink);
			}
			if(left_len >= size)
				return NULL;
			snprintf(left, size, "%s", symlink);
			left_len = strlen(left);
		}
#endif

	}

#ifdef	WIN32
        if(buffer_len > 1 && buffer[buffer_len - 1] == '\\')
                buffer[buffer_len - 1] = 0;
        else if(buffer_len > 1 && buffer[buffer_len - 1] == '/')
                buffer[buffer_len - 1] = 0;
#else
	if(buffer_len > 1 && buffer[buffer_len - 1] == '/')
		buffer[buffer_len - 1] = 0;
#endif
	return buffer;
}

#endif

#ifdef	CCXX_NAMESPACES
}
#endif

/** EMACS **
 * Local variables:
 * mode: c++
 * c-basic-offset: 8
 * End:
 */