yslist.h~

电力故障信息采集,主要是针对南自的保护装置,这个程序用在Linux操作系统下

// YsPtrList.h: interface for the CYsPtrList class.


////////////////////////////////////////////////////////////
/**
 *
 * 文 件 名	: YsList.h
 * 创建日期	: 2006-09
 * 作    者 : 邵凯田([e-mail])
 * 修改日期	: $Date: 2006-10-27$
 * 当前版本	: $Revision: $
 * 功能描述 : YsPtrList YsValueList YsClassList
 * 修改记录 : 
 *            $Log: $
 **/
////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////////

#if !defined(AFX_YSPTRLIST_H__12695A0C_F4BA_4DF7_9F35_17CD7703DDE1__INCLUDED_)
#define AFX_YSPTRLIST_H__12695A0C_F4BA_4DF7_9F35_17CD7703DDE1__INCLUDED_
#include <list>

#include "YsLock.h"

#ifndef NULL
#define NULL 0
#endif

template <class type>
class CYsPtrList
{
public:
	struct NODE
	{
		type *pObj;
		NODE* pNext;
	};
	CYsPtrList()
	{
		m_pNode = NULL;
		m_iSize  = 0;
		m_bAutoDel = false;
		m_bShared = false;
	};
	virtual ~CYsPtrList()
	{
		if(m_bAutoDel)
			clear();
	};
	void setAutoDelete(bool b)
	{
		m_bAutoDel = b;
	}
	bool isShared() {return m_bShared;};
	void setShared(bool b) {m_bShared=b;};

	inline void lock()
	{
		if(m_bShared)
			m_Lock.lock();
	}

	inline void unlock()
	{
		if(m_bShared)
			m_Lock.unlock();
	}

	bool clear()
	{
		lock();
		NODE *next,*p=m_pNode;
		m_pNode = NULL;
		m_iSize  = 0;
		while(p)
		{
			next = p->pNext;
			if(m_bAutoDel)
				delete p->pObj;
			delete p;
			p = next;
		}
		unlock();
		return true;
	}

	bool remove(type *pObj)
	{
		lock();
		NODE *p=m_pNode,*prev=NULL;
		while(p)
		{
			if(p->pObj == pObj)
			{
				if(prev == NULL)//first?
					m_pNode = p->pNext;
				else
					prev->pNext = p->pNext;
				m_iSize --;
				if(m_bAutoDel)
					delete p->pObj;
				delete p;
				unlock();
				return true;
			}
			prev = p;
			p = p->pNext;
		}
		unlock();
		return false;
	}

	bool replace(int i, type*pObj)
	{
		lock();
		NODE *p=m_pNode,*prev=NULL;
		int cnt=0;
		while(p)
		{
			if(i == cnt)
			{
				p->pObj = pObj;
				unlock();
				return true;
			}
			prev = p;
			p = p->pNext;
			cnt ++;
		}
		unlock();
		return false;
	}

	bool remove(int i)
	{
		lock();
		NODE *p=m_pNode,*prev=NULL;
		int cnt=0;
		while(p)
		{
			if(i == cnt)
			{
				if(prev == NULL)//first?
					m_pNode = p->pNext;
				else
					prev->pNext = p->pNext;
				m_iSize --;
				if(m_bAutoDel)
					delete p->pObj;
				delete p;
				unlock();
				return true;
			}
			prev = p;
			p = p->pNext;
			cnt ++;
		}
		unlock();
		return false;
	}

	unsigned int count()
	{
		return m_iSize;
	}

	bool isEmpty()
	{
		return m_iSize == 0;
	}

	bool append(type *pObj)
	{
		lock();
		NODE *p=m_pNode;
		NODE *pNew = new NODE;
		pNew->pObj = pObj;
		pNew->pNext = NULL;
		if(p == NULL)
			m_pNode = pNew;
		else
		{
			while(p->pNext)
				p = p->pNext;
			p->pNext = pNew;
		}
		m_iSize ++;
		unlock();
		return true;
	}

	type * at(int i)
	{
		lock();
		NODE *p=m_pNode,*prev=NULL;
		int cnt=0;
		while(p)
		{
			if(i == cnt)
			{
				unlock();
				return p->pObj;
			}
			prev = p;
			p = p->pNext;
			cnt ++;
		}
		unlock();
		return NULL;
	}

	type * operator[](int i)
	{
		return at(i);
	}

private:
	NODE *m_pNode;
	int m_iSize;
	bool m_bAutoDel;
	bool m_bShared;//是否线程共享，如共享需要信号量互拆
	YsLock m_Lock;

	bool addNode(NODE* pNew)
	{
		pNew->pNext = NULL;
		if(!m_pNode)
			m_pNode = pNew;
		else
		{
			NODE *p=m_pNode;
			while(p->pNext)
				p = p->pNext;
			p->pNext = pNew;
		}
		return true;
	}
};


template <typename T>
class CYsValueList
{
public:
	typedef T* iterator;
	struct iterator2
	{
		void *pObj;
	};
	struct NODE
	{
		T obj;
		NODE* pNext;
	};
	CYsValueList()
	{
		m_pNode = NULL;
		m_iSize  = 0;
	};
	virtual ~CYsValueList()
	{
		clear();
	};

	bool clear()
	{
		NODE *next,*p=m_pNode;
		m_pNode = NULL;
		m_iSize  = 0;
		while(p)
		{
			next = p->pNext;
			delete p;
			p = next;
		}
		return true;
	}

	bool remove(T *pObj)
	{
		NODE *p=m_pNode,*prev=NULL;
		while(p->pNext)
		{
			if(p->pObj == pObj)
			{
				if(prev == NULL)//first?
					m_pNode = p->pNext;
				else
					prev->pNext = p->pNext;
				m_iSize --;
				delete p;
				return true;
			}
			prev = p;
			p = p->pNext;
		}
		return false;
	}

	bool remove(int i)
	{
		NODE *p=m_pNode,*prev=NULL;
		int cnt=0;
		while(p)
		{
			if(i == cnt)
			{
				if(prev == NULL)//first?
					m_pNode = p->pNext;
				else
					prev->pNext = p->pNext;
				m_iSize --;
				delete p;
				return true;
			}
			prev = p;
			p = p->pNext;
			cnt ++;
		}
		return false;
	}

	unsigned int count()
	{
		return m_iSize;
	}

	bool isEmpty()
	{
		return m_iSize == 0;
	}

	bool append(T &obj)
	{
		NODE *p=m_pNode;
		NODE *pNew = new NODE;
		memcpy(&pNew->obj, &obj,sizeof(T));
		pNew->pNext = NULL;
		if(p == NULL)
			m_pNode = pNew;
		else
		{
			while(p->pNext)
				p = p->pNext;
			p->pNext = pNew;
		}
		m_iSize ++;
		return true;
	}

	iterator at(int i)
	{
		NODE *p=m_pNode,*prev=NULL;
		int cnt=0;
		while(p)
		{
			if(i == cnt)
			{
				return &p->obj;
			}
			prev = p;
			p = p->pNext;
			cnt ++;
		}
		return NULL;
	}

	iterator operator[](int i)
	{
		return at(i);
	}

private:
	NODE *m_pNode;
	int m_iSize;

	bool addNode(NODE* pNew)
	{
		pNew->pNext = NULL;
		if(!m_pNode)
			m_pNode = pNew;
		else
		{
			NODE *p=m_pNode;
			while(p->pNext)
				p = p->pNext;
			p->pNext = pNew;
		}
		return true;
	}
};


template <class T>
class CYsClassList
{
public:
	typedef T* iterator;
	struct iterator2
	{
		void *pObj;
	};
	struct NODE
	{
		T obj;
		NODE* pNext;
	};
	CYsClassList()
	{
		m_pNode = NULL;
		m_iSize  = 0;
	};
	virtual ~CYsClassList()
	{
		clear();
	};

	bool clear()
	{
		NODE *next,*p=m_pNode;
		m_pNode = NULL;
		m_iSize  = 0;
		while(p)
		{
			next = p->pNext;
			delete p;
			p = next;
		}
		return true;
	}

	bool remove(T *pObj)
	{
		NODE *p=m_pNode,*prev=NULL;
		while(p->pNext)
		{
			if(p->pObj == pObj)
			{
				if(prev == NULL)//first?
					m_pNode = p->pNext;
				else
					prev->pNext = p->pNext;
				m_iSize --;
				delete p;
				return true;
			}
			prev = p;
			p = p->pNext;
		}
		return false;
	}

	bool remove(int i)
	{
		NODE *p=m_pNode,*prev=NULL;
		int cnt=0;
		while(p)
		{
			if(i == cnt)
			{
				if(prev == NULL)//first?
					m_pNode = p->pNext;
				else
					prev->pNext = p->pNext;
				m_iSize --;
				delete p;
				return true;
			}
			prev = p;
			p = p->pNext;
			cnt ++;
		}
		return false;
	}

	unsigned int count()
	{
		return m_iSize;
	}

	bool isEmpty()
	{
		return m_iSize == 0;
	}

	bool append(T &obj)
	{
		NODE *p=m_pNode;
		NODE *pNew = new NODE;
		pNew->obj = obj;
		//memcpy(&pNew->obj, &obj,sizeof(T));
		pNew->pNext = NULL;
		if(p == NULL)
			m_pNode = pNew;
		else
		{
			while(p->pNext)
				p = p->pNext;
			p->pNext = pNew;
		}
		m_iSize ++;
		return true;
	}

	iterator at(int i)
	{
		NODE *p=m_pNode,*prev=NULL;
		int cnt=0;
		while(p)
		{
			if(i == cnt)
			{
				return &p->obj;
			}
			prev = p;
			p = p->pNext;
			cnt ++;
		}
		return NULL;
	}

	iterator operator[](int i)
	{
		return at(i);
	}

private:
	NODE *m_pNode;
	int m_iSize;

	bool addNode(NODE* pNew)
	{
		pNew->pNext = NULL;
		if(!m_pNode)
			m_pNode = pNew;
		else
		{
			NODE *p=m_pNode;
			while(p->pNext)
				p = p->pNext;
			p->pNext = pNew;
		}
		return true;
	}
};
#define QPtrList CYsPtrList
#define QValueList CYsValueList
//typedef CYsPtrList QPtrList;
//typedef CYsValueList QValueList;

#endif // !defined(AFX_YSPTRLIST_H__12695A0C_F4BA_4DF7_9F35_17CD7703DDE1__INCLUDED_)