OpGuard.hpp

#ifndef __OP_GUARD_HPP__
#define __OP_GUARD_HPP__


namespace utils {


/*
 * 类功能：
 * 函数guard的基类，提供了释放guard的公用函数
 */
class OpGuardBase
{
public:
OpGuardBase() : release_(false)
{
}


void release_control(void)
{
release_ = true;
}


protected:
bool release_;
};


/*
 * 类功能：
 * 一般函数guard，函数为无参函数，返回类型可以指定
 */
template<typename R = void>
class OpGuardFun : public OpGuardBase
{
typedef R (*FUNC)(void);
public:
OpGuardFun(FUNC _func) : func_(_func)
{
}


~OpGuardFun()
{
if(!this->release_)
{
(*func_)();
}
}
private:
FUNC func_;
};


/*
 * 类功能：
 * 一般函数guard，参数和返回类型均可指定
 */
template<typename P, typename R = void>
class OpGuardFun_Para : public OpGuardBase
{
typedef R (*FUNC)(P);
public:
OpGuardFun_Para(FUNC _func, P _para) 
: func_(_func)
, para_(_para)
{
}


~OpGuardFun_Para()
{
if(!this->release_)
{
(*func_)(para_);
}
}
private:
FUNC func_;
P para_;
};


template<typename P, typename P1, typename R = void>
class OpGuardFun_Para2 : public OpGuardBase
{
typedef R (*FUNC)(P,P1);
public:
OpGuardFun_Para2(FUNC func, P para, P1 para1) 
: func_(func)
, para_(para)
, para1_(para1)
{
}


~OpGuardFun_Para2()
{
if(!this->release_)
{
(*func_)(para_, para1_);
}
}
private:
FUNC func_;
P para_;
P1 para1_;
};




/*
 * 类功能：
 * 成员函数guard，无参函数，返回类型可指定
 */
template<typename T, typename R = void>
class OpGuardFun_Mem : public OpGuardBase
{
typedef R (T::*FUNC)(void);
public:
OpGuardFun_Mem(FUNC _func, T& _obj) 
: func_(_func)
, obj_(_obj)
{
}


~OpGuardFun_Mem()
{
if(!this->release_)
{
(obj_.*func_)();
}
}
private:
FUNC func_;
T& obj_;
};


/*
 * 类功能：
 * 成员函数guard（const函数），无参函数，返回类型可指定
 */
template<typename T, typename R = void>
class OpGuardFun_MemConst : public OpGuardBase
{
typedef R (T::*FUNC)(void) const;
public:
OpGuardFun_MemConst(FUNC _func, T& _obj) 
: func_(_func)
, obj_(_obj)
{
}


~OpGuardFun_MemConst()
{
if(!this->release_)
{
(obj_.*func_)();
}
}
private:
FUNC func_;
T& obj_;
};


/*
 * 类功能：
 * 成员函数guard，参数和返回类型均可指定
 */
template<typename T, typename P, typename R = void>
class OpGuardFun_MemPara : public OpGuardBase
{
typedef R (T::*FUNC)(P);
public:
OpGuardFun_MemPara(FUNC _func, T& _obj, P _para)
: func_(_func)
, obj_(_obj)
, para_(_para)
{
}


~OpGuardFun_MemPara()
{
if(!this->release_)
{
(obj_.*func_)(para_);
}
}
private:
FUNC func_;
T& obj_;
P para_;
};


template<typename T, typename P1, typename P2, typename R = void>
class OpGuardFun_MemPara2 : public OpGuardBase
{
typedef R (T::*FUNC)(P1, P2);
public:
OpGuardFun_MemPara2(FUNC _func, T& _obj, P1 _para1, P2 _para2)
: func_(_func)
, obj_(_obj)
, para1_(_para1)
, para2_(_para2)
{
}


~OpGuardFun_MemPara2()
{
if(!this->release_)
{
(obj_.*func_)(para1_, para2_);
}
}
private:
FUNC func_;
T& obj_;
P1 para1_;
P2 para2_;
};


/*
 * 类功能：
 * 成员函数guard（const函数），参数和返回类型均可指定
 */
template<typename T, typename P, typename R = void>
class OpGuardFun_MemParaConst : public OpGuardBase
{
typedef R (T::*FUNC)(P) const;
public:
OpGuardFun_MemParaConst(FUNC _func, T& _obj, P _para)
: func_(_func)
, obj_(_obj)
, para_(_para)
{
}


~OpGuardFun_MemParaConst()
{
if(!this->release_)
{
(obj_.*func_)(para_);
}
}
private:
FUNC func_;
T& obj_;
P para_;
};


template<typename P>
class DelObjGuard : public OpGuardBase
{
public:
DelObjGuard(P* _para)
: para_(_para)
{
}


~DelObjGuard()
{
if((!this->release_) && (para_ != NULL))
{
delete para_;
}
}
private:
P* para_;
};


template<typename P>
class DelAryGuard : public OpGuardBase
{
public:
DelAryGuard(P* _para)
: para_(_para)
{
}


~DelAryGuard()
{
if((!this->release_) && (para_ != NULL))
{
delete [] para_;
}
}
private:
P* para_;
};


}


#endif