vbaseobject.cpp

otl简单包装实现类,对数据库进行操作的,简单易用.

/***************************************************************************
                          vbaseobject.cpp  -  description
                             -------------------
    begin                : ?  3? 4 2003
    copyright            : (C) 2003 by |??|
    email                : |[e-mail]|
 ***************************************************************************/

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

#include "vbaseobject.h"
#include <linux/errno.h>

///////////////////////////----------------------------------------------------------------------------------
VCritiSec::VCritiSec()
{
    pthread_mutex_init(&m_Mutex,NULL);
}
VCritiSec::~VCritiSec()
{
    pthread_mutex_destroy(&m_Mutex);
}
void VCritiSec::Lock()
{
    pthread_mutex_lock(&m_Mutex);
}
void VCritiSec::Unlock()
{
    pthread_mutex_unlock(&m_Mutex);
}

//////////////////////////------------------------------------------------------------------------------------
VEvent::VEvent()
{   
     pthread_cond_init(&m_ECond,NULL);
     pthread_mutex_init(&m_ELock,NULL);
}

VEvent::~VEvent()
{
       pthread_mutex_destroy(&m_ELock);
       pthread_cond_destroy(&m_ECond);
}

long VEvent::Wait(long msec)
{
	int RetCode = 0;
    pthread_mutex_lock(&m_ELock);
    if(msec>0){
    	struct timeb tb;
    	ftime(&tb);
        struct timespec ts;
        ts.tv_sec = tb.time+(tb.millitm+msec)/1000;
        ts.tv_nsec = ((tb.millitm+msec)%1000)*1000L*1000;
    	 RetCode = pthread_cond_timedwait(&m_ECond,&m_ELock,&ts);
    }
    else{
        pthread_cond_wait(&m_ECond,&m_ELock);
    }
  	pthread_mutex_unlock(&m_ELock);
   if(RetCode==ETIMEDOUT) RetCode=-2;
   else if(RetCode==EINTR)RetCode=-1;
   else RetCode = 0;
   
   return RetCode;
}	
    
void VEvent::Set()
{
    pthread_mutex_lock(&m_ELock);
   	pthread_cond_signal(&m_ECond);
  	pthread_mutex_unlock(&m_ELock);
}

////////////////////////-------------------------------------------------------------------------------
VShmObject::VShmObject()
{
    m_Key = 0;
    m_Size = 0;
    m_Id = -1;
    m_pShm = NULL;
}

VShmObject::~VShmObject()
{
    Destroy();
}

void* VShmObject::Create(size_t Size,key_t Key)
{
    m_Key = Key;
    m_Size = Size;
    if(m_Key<=0){
        m_Key = getpid();
    }
    m_Id = shmget(m_Key,Size,0666|IPC_CREAT);
    if(m_Id==-1){
        return NULL;
    }
    m_pShm = shmat(m_Id,(void*)0,0);
    if(m_pShm==(void*)-1){
        m_pShm = NULL;
    }
    return m_pShm;        
}

void  VShmObject::Destroy()
{
    if(m_pShm){
        shmdt(m_pShm);
        m_pShm = NULL;   
    }
    if(m_Id>=0){
        shmctl(m_Id,IPC_RMID,0);
        m_Id = -1;
    }
}

key_t VShmObject::GetKey()
{
    return m_Key;
}

size_t VShmObject::GetSize()
{
	struct shmid_ds ds;
	if(m_Id>=0){
		if(shmctl(m_Id,IPC_STAT,&ds)==0){
			m_Size = ds.shm_segsz;
		}
	}
  	return m_Size;
}

void* VShmObject::GetShm(int Offset)
{
    if(m_pShm){
        return (char*)m_pShm+Offset;
    }
    else return m_pShm;
}

//////////////////-------------------------------------------------------------------------------------
VMsgObject::VMsgObject()
{
	m_Key = 0;
	m_Id = -1;
}

VMsgObject::~VMsgObject()
{
	
}

int VMsgObject::Create(key_t Key)
{
    m_Key = Key;
    if(m_Key<=0){
        m_Key = getpid();
    }
    m_Id =msgget(m_Key,0666|IPC_CREAT);
    return m_Id;
}

int VMsgObject::Send(void* msgPtr,size_t msgSize)
{
	return msgsnd(m_Id,msgPtr,msgSize,0);
}

int VMsgObject::Recv(long int msgType,void* msgPtr,size_t msgSize)
{
	return msgrcv(m_Id,msgPtr,msgSize,msgType,0);	
}

void VMsgObject::Destroy()
{
    if(m_Id>=0){
        msgctl(m_Id,IPC_RMID,0);
        m_Id = -1;
    }
}

//////////////////////--------------------------------------------------------------------------------------
VFileLock::VFileLock()
{
	m_LockFd = -1;
	memset(m_LockFile,0,256);
}

VFileLock::~VFileLock()
{
	Close();
}

int  VFileLock::Open(const char* LockFile)
{
	strcpy(m_LockFile,LockFile);
	m_LockFd = open(m_LockFile,O_RDWR|O_CREAT,0666);
	return m_LockFd;
}

int  VFileLock::Open(VFileLock& FLock)
{
	strcpy(m_LockFile,FLock.m_LockFile);
	m_LockFd = dup(FLock.m_LockFd);
	return m_LockFd;
}

void  VFileLock::Close()
{
	if(m_LockFd>=0){
		close(m_LockFd);
		m_LockFd = -1;
	}
}

int   VFileLock::Lock_Reg(int Cmd,int Type,off_t Offset,off_t Len)
{
	if(m_LockFd<0) return -1;
	
	struct flock lock;
	lock.l_type = Type;
	lock.l_start = Offset;
	lock.l_whence = SEEK_SET;
	lock.l_len = Len;
	
	return fcntl(m_LockFd,Cmd,&lock);
}

int   VFileLock::ReadLock(off_t Offset,off_t Len)
{
	if(m_LockFd<0) return -1;
	return Lock_Reg(F_SETLK,F_RDLCK,Offset,Len);
}

int   VFileLock::WriteLock(off_t Offset,off_t Len)
{
	if(m_LockFd<0) return -1;
	return Lock_Reg(F_SETLK,F_WRLCK,Offset,Len);
}

int   VFileLock::ReadBlock(off_t Offset,off_t Len)
{
	if(m_LockFd<0) return -1;
	return Lock_Reg(F_SETLKW,F_RDLCK,Offset,Len);
}

int   VFileLock::WriteBlock(off_t Offset,off_t Len)
{
	if(m_LockFd<0) return -1;
	return Lock_Reg(F_SETLKW,F_WRLCK,Offset,Len);
}

int   VFileLock::VFileLock::Unlock(off_t Offset,off_t Len)
{
	if(m_LockFd<0) return -1;
	return Lock_Reg(F_SETLK,F_UNLCK,Offset,Len);
}

int   VFileLock::Read(char* Buf,off_t Offset,off_t Len)
{
	if(m_LockFd<0) return -1;
	lseek(m_LockFd,Offset,SEEK_SET);
	return read(m_LockFd,Buf,Len);
}

int   VFileLock::Write(const char* Buf,off_t Offset,off_t Len)
{
	if(m_LockFd<0) return -1;
	lseek(m_LockFd,Offset,SEEK_SET);
	return write(m_LockFd,Buf,Len);
}
//////////////////////--------------------------------------------------------------------------------------
VVThread::VVThread()
{
   	m_Pid= 0;
    ProxyThreadFunc = NULL;
    m_pArg = NULL;
}

VVThread::VVThread(VVTHREAD ThreadFunc,void* Arg)
{
	SetThread(ThreadFunc,Arg);
}

VVThread::~VVThread()
{
		
}

void VVThread::SetThread(VVTHREAD ThreadFunc,void* Arg)
{
	m_Pid = 0;
	ProxyThreadFunc = ThreadFunc;
	m_pArg = Arg;
}

bool VVThread::Start()
{
	bool bSuccess = false;
	if(ProxyThreadFunc){
		if(pthread_create(&m_Pid,NULL,ProxyThreadFunc,m_pArg)==0){
         	bSuccess = true;
		}
	}
	return bSuccess;
}

void VVThread::Detach()
{
    if(m_Pid>0) pthread_detach(m_Pid);
}

void VVThread::Join()
{
	if(m_Pid>0)pthread_join(m_Pid,0);
}
//////////////////////--------------------------------------------------------------------------------------
VVThreadGroup::VVThreadGroup()
{
	
}

VVThreadGroup::~VVThreadGroup()
{
	VAutoLock al(&m_CriGroup);
	for(std::list<VVThread*>::iterator it=m_Group.begin(); it!=m_Group.end();it++){
     	delete (*it);
	}
	m_Group.clear();	
}

VVThread* VVThreadGroup::Create(VVTHREAD ThreadFunc,void* Arg)
{
    VVThread* pThread = new VVThread(ThreadFunc,Arg);
    Add(pThread);
    return pThread;
}

void VVThreadGroup::Add(VVThread* pThread)
{
    VAutoLock al(&m_CriGroup);
    std::list<VVThread*>::iterator it = std::find(m_Group.begin(),m_Group.end(),pThread);
    if(it==m_Group.end()){
	    m_Group.push_back(pThread);
	}
}

void VVThreadGroup::Remove(VVThread* pThread)
{
    VAutoLock al(&m_CriGroup);
    std::list<VVThread*>::iterator it = std::find(m_Group.begin(),m_Group.end(),pThread);
    if(it!=m_Group.end()){
	    m_Group.erase(it);
	}
}

void VVThreadGroup::Join()
{
    VAutoLock al(&m_CriGroup);
    for(std::list<VVThread*>::iterator it = m_Group.begin();it!=m_Group.end();it++){
     	(*it)->Join();
	}
}

void VVThreadGroup::Delete()
{
	VAutoLock al(&m_CriGroup);
	for(std::list<VVThread*>::iterator it = m_Group.begin();it!=m_Group.end();it++){
		delete *(it);
	}
	m_Group.clear();
}
//////////////////////--------------------------------------------------------------------------------------