xmlcache.h

可移植的xml库。已经在windows和linux上测试通过。只使用C++ Runtine

#ifndef LIBXML_XMLCACHE_H
#define LIBXML_XMLCACHE_H

//xmlcache.h

class CXMLAttrib;
class CXMLNode;

//to foolish Visual Studio IDE
#ifdef WIN32
	struct pthread_mutex_t;
	extern void pthread_mutex_init(pthread_mutex_t *);
	extern void pthread_mutex_destroy(pthread_mutex_t *);
	extern void pthread_mutex_lock(pthread_mutex_t *);
	extern void pthread_mutex_unlock(pthread_mutex_t *);
#endif

class CLock
{
#ifdef WIN32
	HANDLE m_mut;
#else
	pthread_mutex_t m_mut;
#endif
public:
	CLock();
	~CLock();
	void lock();
	void unlock();
};

class CAutolock
{
	CLock *m_lock;
public:
	CAutolock(CLock& lock);
	CAutolock(CLock *lock);
	~CAutolock();
	void lock();
	void unlock();
	void detach();
	void attach(CLock& lock);
	void attach(CLock *lock);
};

class CXMLAttribCache
{
	CLock m_lock;
	unsigned m_alimit;
	unsigned m_flimit;
	unsigned m_acount;
	unsigned m_fcount;
	CXMLAttrib *m_last;
	CXMLAttrib *m_first;
public:
	CXMLAttribCache();
	~CXMLAttribCache();

	unsigned getAllocLimit() const;
	unsigned getFreeLimit() const;
	unsigned getAllocCount() const;
	unsigned getFreeCount() const;

	void setAllocLimit(unsigned limit);
	void setFreeLimit(unsigned limit);

	void clean();

	void saveup(CXMLAttrib *a);
	CXMLAttrib* reuse(bool nonew=false);
};

class CXMLNodeCache
{
	CLock m_lock;
	unsigned m_alimit;
	unsigned m_flimit;
	unsigned m_acount;
	unsigned m_fcount;
	CXMLNode *m_last;
	CXMLNode *m_first;
	CXMLAttribCache m_xac;
public:
	CXMLNodeCache();
	~CXMLNodeCache();

	unsigned getAllocLimit() const;
	unsigned getFreeLimit() const;
	unsigned getAllocCount() const;
	unsigned getFreeCount() const;

	void setAllocLimit(unsigned limit);
	void setFreeLimit(unsigned limit);

	CXMLAttribCache& getAttribCache();
	
	void clean();

	void saveup(CXMLNode *a);
	CXMLNode* reuse(bool nonew=false);
	CXMLAttrib* allocAttrib(bool nonew=false);
};


inline CAutolock::CAutolock(CLock& lock) : m_lock(&lock){lock.lock();}
inline CAutolock::CAutolock(CLock *lock) : m_lock(lock)
{
	assert(m_lock);
	m_lock->lock();
}
inline CAutolock::~CAutolock(){if(m_lock) m_lock->unlock();}
inline void CAutolock::lock()
{
	assert(m_lock);
	m_lock->lock();
}
inline void CAutolock::unlock()
{
	assert(m_lock);
	m_lock->unlock();
}
inline void CAutolock::detach(){m_lock=0;}
inline void CAutolock::attach(CLock& lock){m_lock=&lock;}
inline void CAutolock::attach(CLock *lock){m_lock=lock;}

inline unsigned CXMLAttribCache::getAllocLimit() const{return m_alimit;}
inline unsigned CXMLAttribCache::getFreeLimit() const{return m_flimit;}
inline unsigned CXMLAttribCache::getAllocCount() const{return m_acount;}
inline unsigned CXMLAttribCache::getFreeCount() const{return m_fcount;}

inline void CXMLAttribCache::setAllocLimit(unsigned limit){m_alimit=limit;}
inline void CXMLAttribCache::setFreeLimit(unsigned limit){m_flimit=limit;}

inline unsigned CXMLNodeCache::getAllocLimit() const{return m_alimit;}
inline unsigned CXMLNodeCache::getFreeLimit() const{return m_flimit;}
inline unsigned CXMLNodeCache::getAllocCount() const{return m_acount;}
inline unsigned CXMLNodeCache::getFreeCount() const{return m_fcount;}

inline void CXMLNodeCache::setAllocLimit(unsigned limit){m_alimit=limit;}
inline void CXMLNodeCache::setFreeLimit(unsigned limit){m_flimit=limit;}

inline CXMLAttribCache& CXMLNodeCache::getAttribCache(){return m_xac;}
inline CXMLAttrib* CXMLNodeCache::allocAttrib(bool nonew){return m_xac.reuse(nonew);}

#endif//LIBXML_XMLCACHE_H