mmap.h

用于汉字识别和分类的支持向量机SVMTEST测试算法,很好用啊

/*
 MeCab -- Yet Another Part-of-Speech and Morphological Analyzer

 $Id: mmap.h,v 1.3 2002/10/14 09:40:05 taku-ku Exp $;

 Copyright (C) 2001-2002  Taku Kudo <[e-mail]>
 All rights reserved.

 This library is free software; you can redistribute it and/or
 modify it under the terms of the GNU Library General Public
 License as published by the Free Software Foundation; either
 version 2 of the License, or (at your option) any later verjsion.

 This library 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.  See the GNU
 Library General Public License for more details.

 You should have received a copy of the GNU Library General Public
 License along with this library; if not, write to the
 Free Software Foundation, Inc., 59 Temple Place - Suite 330,
 Boston, MA 02111-1307, USA.
*/
#ifndef _MECAB_MMAP_H
#define _MECAB_MMAP_H

#pragma warning(disable: 4786)//CCR 2004.04.05

#include <errno.h>
#include <stdexcept>
#include <string>

#ifdef HAVE_CONFIG_H
#include "config.h"
#endif

extern "C" {

#ifdef HAVE_SYS_TYPES_H   
#include <sys/types.h>
#endif

#ifdef HAVE_SYS_STAT_H
#include <sys/stat.h>
#endif

#ifdef HAVE_FCNTL_H
#include <fcntl.h>
#endif

#ifdef HAVE_STRING_H
#include <string.h>
#endif

#if defined (_WIN32) && !defined (__CYGWIN__)
#ifdef HAVE_WINDOWS_H
#include <windows.h>
#endif
#else
   
#ifdef HAVE_SYS_MMAN_H
#include <sys/mman.h>
#endif

#ifdef HAVE_UNISTD_H
#include <unistd.h>
#endif
#endif
}

#ifndef O_BINARY
#define O_BINARY 0
#endif

#if !defined (_WIN32) || defined (__CYGWIN__)
/*************************CCR DELETE **********************************************************
//static inline int open__ (const char* name, int flag) { return open (name, flag); }
//static inline int close__ (int fd) { return close (fd); }
/***********************************************************************************************/
/*****************************************CCR ADD***********************************************/
#include <fcntl.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <io.h>

static inline int open__ (const char* name, int flag) { return _open (name, flag); }
static inline int close__ (int fd) { return _close (fd); }
#endif
/****************************************CCR ADD************************************************/
namespace YamCha
{
	template <class T>
	class Mmap 
	{
	private:
		T             *text;
		unsigned int  length;
		std::string        fileName;
		std::string        _what; 

	#if defined (_WIN32) && !defined (__CYGWIN__)
	    HANDLE hFile;
		HANDLE hMap;
		//int hFile; //CCR ADD
		//int hMap;  //CCR ADD
	#else
		int    fd;
		int    flag;
	#endif

	public:
		T&       operator [] (unsigned int n)       { return *(text + n); }
		const T& operator [] (unsigned int n) const { return *(text + n); }
		T*       begin ()           { return text; }
		const T* begin ()    const  { return text; }
		T*       end   ()           { return text + size(); }
		const T* end   ()    const  { return text + size(); }
		unsigned int size ()        { return length/sizeof(T); }
		const char *what ()         { return _what.c_str(); }
		const char *getFileName ()  { return fileName.c_str(); }
		unsigned int getFileSize () { return length; }
    
		/*
		 *  This code is imported from sufary, develoved by
		 *  TATUO Yamashita <[e-mail]> Thanks!
		 */ 
	#if defined (_WIN32) && !defined (__CYGWIN__)
		bool open(const char *filename, const char *mode = "r")
		{
			try
			{
				this->close();
				unsigned long mode1, mode2, mode3;
				fileName = std::string (filename);

				if (strcmp(mode, "r") == 0)
				{
					mode1 = GENERIC_READ;
					mode2 = PAGE_READONLY;
					mode3 = FILE_MAP_READ;
				} 
				else if (strcmp(mode, "r+") == 0)
				{
					mode1 = GENERIC_READ | GENERIC_WRITE;
					mode2 = PAGE_READWRITE;
					mode3 = FILE_MAP_ALL_ACCESS;
				}
				else
				{
					throw std::runtime_error ("unknown open mode");
				}
 
				hFile = CreateFile(filename, mode1, FILE_SHARE_READ, 0,
									OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, 0);
				if (hFile == INVALID_HANDLE_VALUE) 
				{
					throw std::runtime_error ("CreateFile() failed");
				}  

				length = GetFileSize (hFile, 0);

				hMap = CreateFileMapping (hFile, 0, mode2, 0, 0, 0);
				if (! hMap)
				{
					throw std::runtime_error ("CreateFileMapping() failed");
				}

				text = (T *)MapViewOfFile (hMap, mode3, 0, 0, 0);
				if (! text)
				{
					throw std::runtime_error ("MapViewOfFile() failed");
				}	

				return true;
			}

			catch (std::exception &e)
			{
				this->close();
				_what  = "Mmap::open(): " + std::string (filename) + " : " + e.what ();
				return false;
			}
		}

		bool close()
		{
			  if (text)
			  {
				  UnmapViewOfFile (text); text = 0; 
			  }
      
			  if (hFile != INVALID_HANDLE_VALUE)
			  { 
				  CloseHandle (hFile); hFile = INVALID_HANDLE_VALUE;
			  }
      
			  if (hMap)
			  {
				  CloseHandle (hMap); hMap = 0; 
			  }

			  return true;
		}

		Mmap (): text(0), hFile (INVALID_HANDLE_VALUE), hMap (0)
		{

		}

		Mmap (const char *filename,const char *mode = "r"):text(0),hFile(INVALID_HANDLE_VALUE),hMap(0)
		{
			if (! this->open (filename, mode))
			{
				throw std::runtime_error (_what);
			}
				
		}     

	#else

		bool open (const char *filename, const char *mode = "r")
		{
			try
			{
				this->close ();
				struct stat st;
				fileName = std::string(filename);
				 
				if (strcmp (mode, "r") == 0)
				{
					flag = O_RDONLY; 
				}
				else if (strcmp (mode, "r+") == 0)
				{
					flag = O_RDWR;
				}
				else
				{
					throw std::runtime_error ("unknown open mode");
				}
				 
				if ((fd = open__ (filename, flag | O_BINARY)) < 0)
				{
					throw std::runtime_error ("open() failed");
				}
				  
				if (fstat (fd, &st) < 0)
				{
					 throw std::runtime_error ("failed to get file size");
				}
				 
				
				length = (unsigned int)st.st_size;

			#ifdef HAVE_MMAP
				int prot = PROT_READ;
				if (flag == O_RDWR) prot |= PROT_WRITE;
				char *p;
				if ((p = (char *)mmap (0, length, prot, MAP_SHARED, fd, 0)) == MAP_FAILED) 
				{
						throw std::runtime_error ("mma p() failed");
				}
				
				text = reinterpret_cast<T *>(p);

			#else
				text = new T [length];
				if (read (fd, text, length) < 0) 
				{
					throw std::runtime_error ("read() failed");
				}
			#endif
				close__ (fd);
				fd = -1;

				return true;
			}

			 catch (std::exception &e)
			 {
				 this->close();
				 _what  = "Mmap::open(): " + std::string (filename) + " : " + e.what ();
				 return false;
			  }
		}

		bool close ()
		{
			if (fd >= 0)
			{
				close__ (fd); fd = -1;
			}
			
			if (text)
			{
			 
			#ifdef HAVE_MMAP
				munmap ((char *)text, length);
			#else
				if (flag == O_RDWR)
				{
					int fd2; 
					
					if ((fd2 = open__ (fileName.c_str(), O_RDWR)) >= 0)
					{
						write (fd2, text, length);
						close__ (fd2);
					}
				}
				
				delete [] text;
				text = 0;
			#endif    
			}

			return true;
		}

		Mmap (): text(0), fd (-1) 
		{
		}

		Mmap (const char *filename, const char *mode = "r"):text(0), fd (-1)
		{
			if (! this->open (filename, mode))
			{
				throw std::runtime_error (_what);
			}
		}
	#endif      

		~Mmap ()
		{
			this->close (); 
		}
	};
}
#endif