访问模型一 最简单的访问服务器

#pragma once

#include <memory>
#include <string>



class MyLink {
private:
	struct LinkNode {
		std::string key_;
		std::string value_;
		std::shared_ptr<LinkNode> next_;
		std::shared_ptr<LinkNode> prev_;
	};
public:
	MyLink() :head_(nullptr), tail_(nullptr), nodeCount_(0){}
	MyLink(std::string key,std::string value){
		head_ = tail_ = InitNode(key,value);
		nodeCount_ = 1;
	}

	~MyLink() {
		if (head_ == nullptr) {
			return;
		}
		while (head_ != nullptr) {
			std::shared_ptr<LinkNode> p = head_;
			if (p->next_ == nullptr) {
				head_ = tail_ = nullptr;
				nodeCount_--;
				break;
			}
			head_ = p->next_;
			p->next_ = nullptr;
			head_->prev_ = nullptr;
			nodeCount_--;
		}
	}

	size_t GetNodeCount() {return nodeCount_;}

	void PrintNode() {
		std::shared_ptr<LinkNode> p = head_;
		for (; p != nullptr; p = p->next_) {
			std::cout << p->key_ << " " << p->value_ << std::endl;
		}
		std::cout << std::endl;
	}

	std::shared_ptr<LinkNode> FindNode(const std::string key,const std::string value) {
		std::shared_ptr<LinkNode> p = nullptr;
		if (nullptr == tail_ || nullptr == head_) {
			return p;
		}

		for (std::shared_ptr<LinkNode> p = head_; p != nullptr; p = p->next_) {
			if (p->key_ == key && p->value_ == value )
				return p;
		}

		return nullptr;
	}


	std::shared_ptr<LinkNode> FindNode(std::shared_ptr<LinkNode> node) {
		std::shared_ptr<LinkNode> p = nullptr;
		if (node == nullptr)
			return p;
		if (nullptr == tail_ || nullptr == head_) {
			return p;
		}

		for (std::shared_ptr<LinkNode> p = head_; p != nullptr; p = p->next_) {
			if (p->key_ == node->key_ && p->value_ == node->value_)
				return p;
		}
		
		return nullptr;
	}

	bool DeleteNode(const std::string key, const std::string value) {
		std::shared_ptr<LinkNode>p = FindNode(key, value);
		if ( p  == nullptr  ) {
			return false;
		}
		if (p->prev_ == nullptr && p->next_ == nullptr) {
			head_ =  tail_ = nullptr;	
		}else if (p->prev_ == nullptr) {
			head_ = p->next_;
			p->next_ = nullptr;
			head_->prev_ = nullptr;
		}
		else if (p->next_ == nullptr) {
			tail_ = p->prev_;
			tail_->next_ = nullptr;
			p->prev_ = nullptr;
		}else {
			p->prev_->next_ = p->next_;
			p->next_->prev_ = p->prev_;
			p->prev_ = p->next_ = nullptr;
		}
		nodeCount_--;
		return true;
	}

	bool DeleteNode(std::shared_ptr<LinkNode>& node) {
		std::shared_ptr<LinkNode>p = FindNode(node);
		if (p == nullptr) {
			return false;
		}
		if (p->prev_ == nullptr && p->next_ == nullptr) {
			head_ = tail_ = nullptr;
		}
		else if (p->prev_ == nullptr) {
			head_ = p->next_;
			p->next_ = nullptr;
			head_->prev_ = nullptr;
		}
		else if (p->next_ == nullptr) {
			tail_ = p->prev_;
			tail_->next_ = nullptr;
			p->prev_ = nullptr;
		}
		else {
			p->prev_->next_ = p->next_;
			p->next_->prev_ = p->prev_;
			p->prev_ = p->next_ = nullptr;
		}
		nodeCount_--;
		return true;
	}

	bool AppendNode(std::string key, std::string value) {

		return AppendNode(InitNode(key,value));
	}

	bool AppendNode(std::shared_ptr<LinkNode> node) {
		bool ret = false;
		if (nullptr == head_  && nullptr  == tail_) {
			head_ = tail_ = node;
			nodeCount_++;
			ret = true;
			return ret;
		}
		else if (nullptr == tail_ || nullptr == head_) {
			return ret;
		}
		
		tail_->next_ = node;
		node->prev_ = tail_;
		tail_ = node;
		node->next_ = nullptr;
		nodeCount_++;

		ret = true;
		return ret;
	}

	static std::shared_ptr<LinkNode> InitNode(const std::string& key, const std::string& value) {
		std::shared_ptr<LinkNode> p(new LinkNode);
		p->key_ = key;
		p->value_ = value;
		p->next_ = nullptr;
		p->prev_ = nullptr;
		return p;
	}
private:
	

	MyLink(const MyLink&);
	const MyLink& operator=(const MyLink&);
	size_t nodeCount_;
	std::shared_ptr<LinkNode> head_;
	std::shared_ptr<LinkNode> tail_;
};