squid 源码学习2

// 下面的类共同协作，完成了一个对象链表
// 任何从AsyncCall继承的对象都可以插入链表 ，拥有可定义的fire函数，实现自己的功能，并在链表中依次被调动
// 链表中对象都可自动记录引用计数

// 基类， 完成记录次数的自增自减和返回
struct RefCountable_{
	RefCountable_():count_(0){}
	virtual ~ReCountable_(){assert(count_ == 0);}
         // 自增
	void RefCountReference() const{
		++count_;
	}
        // 自减
	unsigned RefCountDereference()const{
		return --count_;
	}
	
 	// 返回
	unsigned RefCountCount()const {return count_;}
	private:
	mutable unsigned count_; // 在const里可以被修改
};
#define RefCountable virtual RefCountable_
template <class C>  // C 都是从RefCountable_继承 有 次数自增和自减的函数
class  RefCount // 此类保存 C类的对象指针 用来管理对象的引用计数
{
public:
	RefCount():p_(NULL){}; // 默认构造函数
	RefCount(C const *p):p_(p){reference(*this);} // 一般构造函数
	~RefCount(){ // 析构函数
		dereference();
	}
	RefCount(const RefCount &p):p_(p.p_){ // 拷贝构造函数
		reference(p);
	}
	
	// 赋值构造函数 原先对象多一，本
	RefCount &operator = (const RefCount &p){
		C const *newP_ = p.p_;
		reference(p);
		dereference(newP_);
		return *this;
	}
	//对p_成员取反后返回
	bool operator !() const{
		return !p_;
	}	
        
	// 取指针取值
	 C* operator ->()const{return const_cast<C*>(p_);}
	C & operator *()const { return *const_cast<C*>(P_);}
	// 获取原始指针
	C const * getRaw()const {return p_;}
	C * getRaw(){return const_cast<C*>(p_);}
 	//相等和不等的比较
	bool operator == (const RefCount &p) const{
		return p.p_ == p_;
	}
	bool operator != (const RefCount &p) const{
		return p.p_ != p_;
	}
private:
	// 原先指针调用RefCountDereference 然后释放，保存新指针
	void dereference(C const *newP_ = null){
		C const (*tempP_)(p_);
		p_ = newP;
		if (tempP_ && tempP_->RefCountDereference() == 0)
		{
			delete tempP_;
		}
	
 	}
	
	void  reference (const RefCount &p)
	{
		if (p.p_)
		{
			p.p_->RefCountReference();
		}
	}
	C const *p_; // C为模板类型
}
class AsyncCall :public RefCountable
{
	public:
	typedef RefCount <AsyncCall> Pointer;
	friend class AsyncCallQueue;
	AsyncCall(int aDebugSection, int aDebugLevel, const char *aName);
	virtual ~AsyncCall();
	void make();
	bool cancel(const char *reason);
	bool canceled(){return isCanceled != NULL;} // 不为空为true 为真取消 ==空 为假
	virtual  CallDialar * getDialar() = 0;
	void print(std::ostream &os);
	void dequeue(AsyncCall :: Pointer &head, AsyncCall::Pointer &prev);
	void setNext(AsyncCall::Pointer aNext)
	{
		theNext = aNext;
	}	
	AsyncCall::Pointer &Next(){return thNext;}
public:
	const char*const name;
	const int debugSection;
	const int debugLevel;
	const InstanceId<AsyncCall> id;
protected:
	virtual bool canFire();
	virtual void fire() = 0;
	AsyncCall :: Pointer theNext;
private:
	const char *isCanceled;
	
	AsyncCall();
	AsyncCall(const AsyncCall &);
}
AsyncCall::AsyncCall(int aDebugSection, int aDebugLevel, const char *aName):name(aName),DebugSection(aDebugSection),theNext(0),isCanceled(Null){}
AsyncCall::~AsyncCall(){assert(!theNext);} // theNext为非空时，就是存在值时，被断住
void AsyncCall::make()
{
	if (canFire())
	{
		fire();
		return;
	}
	if (!isCanceled)
		isCanceled = "unknown reason";
}
bool AsyncCall::cancel(const char * reason)
{
	isCanceled = reason;
	return false;
}
bool AsyncCall::canFire()
{
	return !isCanceled;
}
void AsyncCall::print(std::ostream &os)
{
	os<<name;
	if (const CallDialer *dialar = getDialer())
		dialar->print(os);
	else
		os<<"(?"<<this<<"?)";
}
void AsyncCall::dequeue(AsyncCall::Pointer &head, AsyncCall::Pointer &prev)
{
	if (prev != NULL)
		prev->setNext(Next());
	else
		head = Next();
	setNext(NULL)
}

class AsyncCallQueue // 链表的单间类
{
public:
	static AsyncCallQueue &Instance();
	void schedule(AsyncCall::Pointer &call);
	bool fire();
private:
	AsyncCallQueue(); // 构造函数私有，不能显式创建
	void fireNext();
	AsyncCall::Pointer theHead;
	AsyncCall::Pointer theTail;
	static AsyncCallQueue *TheInstance;
};
AsyncCallQueue* AsyncCallQueue::TheInstance = NULL;
AsyncCallQueue::AsyncCallQueue():theHead(NULL),thTail(NULL){};

// 使用head 和tail 建立链表， head指向链表头， tail指向链表尾部
// 插入时在尾部插入，使用AsyncCall theNext指针指向，然后tail 继续向后移动。
void AsyncCallQueue::schedule(AsyncCall::Pointer &call)
{
	assert(call != NULL);
	assert(!call->theNext); // theNext不用空时断住，必须为空
	if (theHead != NULL){
		assert(!theTail->theNext); // 如果theHead不为空，则 theTail的theNext必须为空才能继续执行
		theTail->theNext = call;
		theTail = call;
	}else{
		theHead = theTail=call;
	}
}

bool AsyncCallQueue::fire（）
{
	const bool made = theHead != NULL;

	// 循环调用链表的pointer成员
	while(theHead != NULL)
	{
		fireNext();
	}
	return made; // 这里只返回判断头是否为空
}

// 调用头部syncCALL对象的make 并把头指针指向下一个
void AsyncCallQueue::fireNext()
{
	AsyncCall::Pointer call = theHead;
	theHead= call->theNext;
	call->theNext = NULL;
	
	if (theTail == call)
		theTail =NULL;

	call->make();
}

// 单间对象获取函数
AsyncCallQueue & AsyncCallQueue :: Instance()
{
	if (!TheInstance)
		TheInstance = new AsyncCallQueue();
	return *TheInstance;
}